From: Markus Koschany Date: Thu, 8 Nov 2018 14:12:11 +0100 Subject: java11-log-error Some methods were removed in Java 11. Bug-Debian: https://bugs.debian.org/910748 --- src/core/lombok/javac/JavacAST.java | 32 -------------------------------- 1 file changed, 32 deletions(-) --- a/src/core/lombok/javac/JavacAST.java +++ b/src/core/lombok/javac/JavacAST.java @@ -1,16 +1,16 @@ /* * Copyright (C) 2009-2025 The Project Lombok Authors. - * + * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: - * + * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. - * + * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE @@ -83,10 +83,10 @@ private final Context context; private static final URI NOT_CALCULATED_MARKER = URI.create("https://projectlombok.org/not/calculated"); private URI memoizedAbsoluteFileLocation = NOT_CALCULATED_MARKER; - + /** * Creates a new JavacAST of the provided Compilation Unit. - * + * * @param errorLog A logger for warning and error reporting. * @param context A Context object for interfacing with the compiler. * @param top The compilation unit, which serves as the top level node in the tree to be built. @@ -104,18 +104,18 @@ this.cleanup = cleanup; clearChanged(); } - + @Override public URI getAbsoluteFileLocation() { if (memoizedAbsoluteFileLocation == NOT_CALCULATED_MARKER) { memoizedAbsoluteFileLocation = getAbsoluteFileLocation((JCCompilationUnit) top().get()); } return memoizedAbsoluteFileLocation; } - + private static Class wrappedFileObjectClass, sbtJavaFileObjectClass, sbtMappedVirtualFileClass, sbtOptionClass; private static Field wrappedFileObjectField, sbtJavaFileObjectField, sbtMappedVirtualFilePathField, sbtMappedVirtualFileRootsField, sbtOptionField; private static Method sbtMapGetMethod; - + public static URI getAbsoluteFileLocation(JCCompilationUnit cu) { try { URI uri = cu.sourcefile.toUri(); @@ -128,7 +128,7 @@ return null; } } - + private static URI tryGetSbtFile(JavaFileObject sourcefile) { try { return tryGetSbtFile_(sourcefile); @@ -136,22 +136,22 @@ return null; } } - + private static URI tryGetSbtFile_(JavaFileObject sourcefile) throws Exception { Class c = sourcefile.getClass(); String cn; - + if (wrappedFileObjectClass == null) { if (!c.getName().equals("com.sun.tools.javac.api.ClientCodeWrapper$WrappedJavaFileObject")) return null; wrappedFileObjectClass = c; } if (c != wrappedFileObjectClass) return null; - + if (wrappedFileObjectField == null) wrappedFileObjectField = Permit.permissiveGetField(wrappedFileObjectClass.getSuperclass(), "clientFileObject"); if (wrappedFileObjectField == null) return null; Object fileObject = wrappedFileObjectField.get(sourcefile); c = fileObject.getClass(); - + if (sbtJavaFileObjectClass == null) { cn = c.getName(); if (!cn.startsWith("sbt.") || !cn.endsWith("JavaFileObject")) return null; @@ -160,10 +160,10 @@ if (sbtJavaFileObjectClass != c) return null; if (sbtJavaFileObjectField == null) sbtJavaFileObjectField = Permit.permissiveGetField(sbtJavaFileObjectClass, "underlying"); if (sbtJavaFileObjectField == null) return null; - + Object mappedVirtualFile = sbtJavaFileObjectField.get(fileObject); c = mappedVirtualFile.getClass(); - + if (sbtMappedVirtualFileClass == null) { cn = c.getName(); if (!cn.startsWith("sbt.") || !cn.endsWith("MappedVirtualFile")) return null; @@ -173,7 +173,7 @@ if (sbtMappedVirtualFilePathField == null) return null; if (sbtMappedVirtualFileRootsField == null) sbtMappedVirtualFileRootsField = Permit.permissiveGetField(sbtMappedVirtualFileClass, "rootPathsMap"); if (sbtMappedVirtualFileRootsField == null) return null; - + String encodedPath = (String) sbtMappedVirtualFilePathField.get(mappedVirtualFile); if (!encodedPath.startsWith("${")) { File maybeAbsoluteFile = new File(encodedPath); @@ -189,7 +189,7 @@ Object roots = sbtMappedVirtualFileRootsField.get(mappedVirtualFile); if (sbtMapGetMethod == null) sbtMapGetMethod = Permit.getMethod(roots.getClass(), "get", Object.class); if (sbtMapGetMethod == null) return null; - + Object option = sbtMapGetMethod.invoke(roots, base); c = option.getClass(); if (sbtOptionClass == null) { @@ -198,19 +198,19 @@ if (c != sbtOptionClass) return null; if (sbtOptionField == null) sbtOptionField = Permit.permissiveGetField(sbtOptionClass, "value"); if (sbtOptionField == null) return null; - + Object path = sbtOptionField.get(option); return new File(path.toString() + encodedPath.substring(idx + 1)).toURI(); } - + private static String sourceName(JCCompilationUnit cu) { return cu.sourcefile == null ? null : cu.sourcefile.toString(); } - + public Context getContext() { return context; } - + /** * Runs through the entire AST, starting at the compilation unit, calling the provided visitor's visit methods * for each node, depth first. @@ -218,11 +218,11 @@ public void traverse(JavacASTVisitor visitor) { top().traverse(visitor); } - + void traverseChildren(JavacASTVisitor visitor, JavacNode node) { for (JavacNode child : node.down()) child.traverse(visitor); } - + @Override public int getSourceVersion() { try { String nm = Source.instance(context).name(); @@ -233,38 +233,38 @@ } catch (Exception ignore) {} return 6; } - + @Override public int getLatestJavaSpecSupported() { return Javac.getJavaCompilerVersion(); } - + public void cleanupTask(String key, JCTree target, CleanupTask task) { cleanup.registerTask(key, target, task); } - + /** @return A Name object generated for the proper name table belonging to this AST. */ public Name toName(String name) { return elements.getName(name); } - + /** @return A TreeMaker instance that you can use to create new AST nodes. */ public JavacTreeMaker getTreeMaker() { treeMaker.at(-1); return treeMaker; } - + /** @return The symbol table used by this AST for symbols. */ public Symtab getSymbolTable() { return symtab; } - + /** * @return The implementation of {@link javax.lang.model.util.Types} of javac. Contains a few extra methods beyond * the ones listed in the official annotation API interface. */ public JavacTypes getTypesUtil() { return javacTypes; } - + /** {@inheritDoc} */ @Override protected JavacNode buildTree(JCTree node, Kind kind) { switch (kind) { @@ -292,7 +292,7 @@ throw new AssertionError("Did not expect: " + kind); } } - + private JavacNode buildCompilationUnit(JCCompilationUnit top) { List childNodes = new ArrayList(); for (JCTree s : top.defs) { @@ -300,14 +300,14 @@ addIfNotNull(childNodes, buildType((JCClassDecl) s)); } // else they are import statements, which we don't care about. Or Skip objects, whatever those are. } - + return new JavacNode(this, top, childNodes, Kind.COMPILATION_UNIT); } - + private JavacNode buildType(JCClassDecl type) { if (setAndGetAsHandled(type)) return null; List childNodes = new ArrayList(); - + for (JCAnnotation annotation : type.mods.annotations) addIfNotNull(childNodes, buildAnnotation(annotation, false)); for (JCTree def : type.defs) { /* A def can be: @@ -321,10 +321,10 @@ else if (def instanceof JCVariableDecl) addIfNotNull(childNodes, buildField((JCVariableDecl) def)); else if (def instanceof JCBlock) addIfNotNull(childNodes, buildInitializer((JCBlock) def)); } - + return putInMap(new JavacNode(this, type, childNodes, Kind.TYPE)); } - + private JavacNode buildField(JCVariableDecl field) { if (setAndGetAsHandled(field)) return null; List childNodes = new ArrayList(); @@ -333,7 +333,7 @@ addIfNotNull(childNodes, buildExpression(field.init)); return putInMap(new JavacNode(this, field, childNodes, Kind.FIELD)); } - + private JavacNode buildLocalVar(JCVariableDecl local, Kind kind) { if (setAndGetAsHandled(local)) return null; List childNodes = new ArrayList(); @@ -342,71 +342,71 @@ addIfNotNull(childNodes, buildExpression(local.init)); return putInMap(new JavacNode(this, local, childNodes, kind)); } - + private JavacNode buildTypeUse(JCTree typeUse) { if (setAndGetAsHandled(typeUse)) return null; - + if (typeUse == null) return null; - + if (typeUse.getClass().getName().equals("com.sun.tools.javac.tree.JCTree$JCAnnotatedType")) { initJcAnnotatedType(typeUse.getClass()); Collection anns = Permit.permissiveReadField(Collection.class, JCANNOTATEDTYPE_ANNOTATIONS, typeUse); JCExpression underlying = Permit.permissiveReadField(JCExpression.class, JCANNOTATEDTYPE_UNDERLYINGTYPE, typeUse); - + List childNodes = new ArrayList(); if (anns != null) for (Object annotation : anns) if (annotation instanceof JCAnnotation) addIfNotNull(childNodes, buildAnnotation((JCAnnotation) annotation, true)); addIfNotNull(childNodes, buildTypeUse(underlying)); return putInMap(new JavacNode(this, typeUse, childNodes, Kind.TYPE_USE)); } - + if (typeUse instanceof JCWildcard) { JCTree inner = ((JCWildcard) typeUse).inner; List childNodes = inner == null ? Collections.emptyList() : new ArrayList(); if (inner != null) addIfNotNull(childNodes, buildTypeUse(inner)); return putInMap(new JavacNode(this, typeUse, childNodes, Kind.TYPE_USE)); } - + if (typeUse instanceof JCArrayTypeTree) { JCTree inner = ((JCArrayTypeTree) typeUse).elemtype; List childNodes = inner == null ? Collections.emptyList() : new ArrayList(); if (inner != null) addIfNotNull(childNodes, buildTypeUse(inner)); return putInMap(new JavacNode(this, typeUse, childNodes, Kind.TYPE_USE)); } - + if (typeUse instanceof JCFieldAccess) { JCTree inner = ((JCFieldAccess) typeUse).selected; List childNodes = inner == null ? Collections.emptyList() : new ArrayList(); if (inner != null) addIfNotNull(childNodes, buildTypeUse(inner)); return putInMap(new JavacNode(this, typeUse, childNodes, Kind.TYPE_USE)); } - + if (typeUse instanceof JCIdent) { return putInMap(new JavacNode(this, typeUse, Collections.emptyList(), Kind.TYPE_USE)); } - + return null; } - + private static boolean JCTRY_RESOURCES_FIELD_INITIALIZED = false; private static Field JCTRY_RESOURCES_FIELD; - + @SuppressWarnings("unchecked") private static List getResourcesForTryNode(JCTry tryNode) { if (!JCTRY_RESOURCES_FIELD_INITIALIZED) { JCTRY_RESOURCES_FIELD = Permit.permissiveGetField(JCTry.class, "resources"); JCTRY_RESOURCES_FIELD_INITIALIZED = true; } - + if (JCTRY_RESOURCES_FIELD == null) return Collections.emptyList(); Object rv = null; try { rv = JCTRY_RESOURCES_FIELD.get(tryNode); } catch (Exception ignore) {} - + if (rv instanceof List) return (List) rv; return Collections.emptyList(); } - + private static boolean JCANNOTATEDTYPE_FIELDS_INITIALIZED = false; private static Field JCANNOTATEDTYPE_ANNOTATIONS, JCANNOTATEDTYPE_UNDERLYINGTYPE; private static void initJcAnnotatedType(Class context) { @@ -415,7 +415,7 @@ JCANNOTATEDTYPE_UNDERLYINGTYPE = Permit.permissiveGetField(context, "underlyingType"); JCANNOTATEDTYPE_FIELDS_INITIALIZED = true; } - + private static Field JCENHANCEDFORLOOP_VARORRECORDPATTERN_FIELD = Permit.permissiveGetField(JCEnhancedForLoop.class, "varOrRecordPattern"); private static JCTree getVarOrRecordPattern(JCEnhancedForLoop loop) { if (JCENHANCEDFORLOOP_VARORRECORDPATTERN_FIELD == null) { @@ -426,7 +426,7 @@ } catch (Exception ignore) {} return null; } - + private JavacNode buildTry(JCTry tryNode) { if (setAndGetAsHandled(tryNode)) return null; List childNodes = new ArrayList(); @@ -440,14 +440,14 @@ addIfNotNull(childNodes, buildStatement(tryNode.finalizer)); return putInMap(new JavacNode(this, tryNode, childNodes, Kind.STATEMENT)); } - + private JavacNode buildInitializer(JCBlock initializer) { if (setAndGetAsHandled(initializer)) return null; List childNodes = new ArrayList(); for (JCStatement statement: initializer.stats) addIfNotNull(childNodes, buildStatement(statement)); return putInMap(new JavacNode(this, initializer, childNodes, Kind.INITIALIZER)); } - + private JavacNode buildMethod(JCMethodDecl method) { if (setAndGetAsHandled(method)) return null; List childNodes = new ArrayList(); @@ -458,7 +458,7 @@ } return putInMap(new JavacNode(this, method, childNodes, Kind.METHOD)); } - + private JavacNode buildAnnotation(JCAnnotation annotation, boolean varDecl) { boolean handled = setAndGetAsHandled(annotation); if (!varDecl && handled) { @@ -467,15 +467,15 @@ } return putInMap(new JavacNode(this, annotation, null, Kind.ANNOTATION)); } - + private JavacNode buildExpression(JCExpression expression) { return buildStatementOrExpression(expression); } - + private JavacNode buildStatement(JCStatement statement) { return buildStatementOrExpression(statement); } - + private JavacNode buildStatementOrExpression(JCTree statement) { if (statement == null) return null; if (statement instanceof JCAnnotation) return null; @@ -485,20 +485,20 @@ if (statement.getClass().getName().equals("com.sun.tools.javac.tree.JCTree$JCLambda")) return buildLambda(statement); if (statement instanceof JCEnhancedForLoop) return buildEnhancedForLoop((JCEnhancedForLoop) statement); if (setAndGetAsHandled(statement)) return null; - + return drill(statement); } - + private JavacNode buildLambda(JCTree jcTree) { return buildStatementOrExpression(getBody(jcTree)); } - + private JCTree getBody(JCTree jcTree) { return (JCTree) Permit.invokeSneaky(getBodyMethod(jcTree.getClass()), jcTree); } - + private final static ConcurrentMap, Method> getBodyMethods = new ConcurrentHashMap, Method>(); - + private Method getBodyMethod(Class c) { Method m = getBodyMethods.get(c); if (m != null) { @@ -512,19 +512,19 @@ getBodyMethods.putIfAbsent(c, m); return getBodyMethods.get(c); } - + private JavacNode buildEnhancedForLoop(JCEnhancedForLoop loop) { if (setAndGetAsHandled(loop)) return null; - + List childNodes = new ArrayList(); // The order of the child elements is important and must be kept addIfNotNull(childNodes, buildTree(getVarOrRecordPattern(loop), Kind.STATEMENT)); addIfNotNull(childNodes, buildTree(loop.expr, Kind.STATEMENT)); addIfNotNull(childNodes, buildStatement(loop.body)); - + return putInMap(new JavacNode(this, loop, childNodes, Kind.STATEMENT)); } - + private JavacNode drill(JCTree statement) { try { List childNodes = new ArrayList(); @@ -539,7 +539,7 @@ throw newError; } } - + /* For javac, both JCExpression and JCStatement are considered as valid children types. */ private static Collection> statementTypes() { Collection> collection = new ArrayList>(3); @@ -548,11 +548,11 @@ collection.add(JCCatch.class); return collection; } - + private static void addIfNotNull(Collection nodes, JavacNode node) { if (node != null) nodes.add(node); } - + /** * Attempts to remove any compiler errors generated by java whose reporting position is located anywhere between the start and end of the supplied node. */ @@ -561,7 +561,7 @@ JCCompilationUnit top = (JCCompilationUnit) top().get(); removeFromDeferredDiagnostics(pos.getStartPosition(), Javac.getEndPosition(pos, top)); } - + /** Supply either a position or a node (in that case, position of the node is used) */ void printMessage(Diagnostic.Kind kind, String message, JavacNode node, DiagnosticPosition pos, boolean attemptToRemoveErrorsInRange) { JavaFileObject oldSource = null; @@ -593,18 +593,18 @@ if (newSource != null) errorLogger.useSource(oldSource); } } - + public void removeFromDeferredDiagnostics(int startPos, int endPos) { JCCompilationUnit self = (JCCompilationUnit) top().get(); new CompilerMessageSuppressor(getContext()).removeAllBetween(self.sourcefile, startPos, endPos); } - + /** {@inheritDoc} */ @Override protected void setElementInASTCollection(Field field, Object refField, List> chain, Collection collection, int idx, JCTree newN) throws IllegalAccessException { com.sun.tools.javac.util.List list = setElementInConsList(chain, collection, ((List)collection).get(idx), newN); field.set(refField, list); } - + private com.sun.tools.javac.util.List setElementInConsList(List> chain, Collection current, Object oldO, Object newO) { com.sun.tools.javac.util.List oldL = (com.sun.tools.javac.util.List) current; com.sun.tools.javac.util.List newL = replaceInConsList(oldL, oldO, newO); @@ -613,7 +613,7 @@ Collection newCurrent = reducedChain.remove(reducedChain.size() -1); return setElementInConsList(reducedChain, newCurrent, oldL, newL); } - + private com.sun.tools.javac.util.List replaceInConsList(com.sun.tools.javac.util.List oldL, Object oldO, Object newO) { boolean repl = false; Object[] a = oldL.toArray(); @@ -623,42 +623,42 @@ repl = true; } } - + if (repl) return com.sun.tools.javac.util.List.from(a); return oldL; } - + abstract static class ErrorLog { final Log log; private final Messager messager; private final Field errorCount; private final Field warningCount; - + private ErrorLog(Log log, Messager messager, Field errorCount, Field warningCount) { this.log = log; this.messager = messager; this.errorCount = errorCount; this.warningCount = warningCount; } - + final JavaFileObject useSource(JavaFileObject file) { return log.useSource(file); } - + final void error(DiagnosticPosition pos, String message) { increment(errorCount); error1(pos, message); } - + final void warning(DiagnosticPosition pos, String message) { increment(warningCount); warning1(pos, message); } - + abstract void error1(DiagnosticPosition pos, String message); abstract void warning1(DiagnosticPosition pos, String message); abstract void note(DiagnosticPosition pos, String message); - + private void increment(Field field) { if (field == null) return; try { @@ -668,7 +668,7 @@ //Very unfortunate, but in most cases it still works fine, so we'll silently swallow it. } } - + static ErrorLog create(Messager messager, Context context) { Field errorCount; try { errorCount = Permit.getField(messager.getClass(), "errorCount"); @@ -682,74 +682,46 @@ hasMultipleErrors = true; } } - if (hasMultipleErrors) return new JdkBefore9(log, messager, errorCount); - + Field warningCount; try { warningCount = Permit.getField(messager.getClass(), "warningCount"); } catch (Throwable t) { warningCount = null; } - + return new Jdk9Plus(log, messager, errorCount, warningCount); } } - - static class JdkBefore9 extends ErrorLog { - private JdkBefore9(Log log, Messager messager, Field errorCount) { - super(log, messager, errorCount, null); - } - - @Override void error1(DiagnosticPosition pos, String message) { - try { - Field multipleErrorsField = log.getClass().getField("multipleErrors"); - boolean prev = multipleErrorsField.getBoolean(log); - multipleErrorsField.setBoolean(log, true); - try { - log.error(pos, "proc.messager", message); - } finally { - multipleErrorsField.setBoolean(log, prev); - } - } catch (Throwable t) {} - } - - @Override void warning1(DiagnosticPosition pos, String message) { - log.warning(pos, "proc.messager", message); - } - - @Override void note(DiagnosticPosition pos, String message) { - log.note(pos, "proc.messager", message); - } - } - + static class Jdk9Plus extends ErrorLog { private static final String PROC_MESSAGER = "proc.messager"; private Object multiple; private Method errorMethod, warningMethod, noteMethod; private Method errorKey, warningKey, noteKey; private JCDiagnostic.Factory diags; - + private Jdk9Plus(Log log, Messager messager, Field errorCount, Field warningCount) { super(log, messager, errorCount, warningCount); - + try { final String jcd = "com.sun.tools.javac.util.JCDiagnostic"; Class df = Class.forName(jcd + "$DiagnosticFlag"); for (Object constant : df.getEnumConstants()) { if (constant.toString().equals("MULTIPLE")) this.multiple = constant; } - + Class errorCls = Class.forName(jcd + "$Error"); Class warningCls = Class.forName(jcd + "$Warning"); Class noteCls = Class.forName(jcd + "$Note"); - + Class lc = log.getClass(); this.errorMethod = Permit.getMethod(lc, "error", df, DiagnosticPosition.class, errorCls); this.warningMethod = Permit.getMethod(lc, "warning", DiagnosticPosition.class, warningCls); this.noteMethod = Permit.getMethod(lc, "note", DiagnosticPosition.class, noteCls); - + Field diagsField = Permit.getField(lc.getSuperclass(), "diags"); this.diags = (JCDiagnostic.Factory) diagsField.get(log); - + Class dc = this.diags.getClass(); this.errorKey = Permit.getMethod(dc, "errorKey", String.class, Object[].class); this.warningKey = Permit.permissiveGetMethod(dc, "warningKey", String.class, Object[].class); @@ -761,12 +733,12 @@ //t.printStackTrace(); } } - + @Override void error1(DiagnosticPosition pos, String message) { Object error = Permit.invokeSneaky(this.errorKey, diags, PROC_MESSAGER, new Object[] { message }); if (error != null) Permit.invokeSneaky(errorMethod, log, multiple, pos, error); } - + @Override void warning1(DiagnosticPosition pos, String message) { Object warning; @@ -777,7 +749,7 @@ } if (warning != null) Permit.invokeSneaky(warningMethod, log, pos, warning); } - + @Override void note(DiagnosticPosition pos, String message) { Object note = Permit.invokeSneaky(this.noteKey, diags, PROC_MESSAGER, new Object[] { message });