JDK 11 jdk.compiler.jmod - Compiler Tool

JDK 11 jdk.compiler.jmod is the JMOD file for JDK 11 Compiler tool, which can be invoked by the "javac" command.

JDK 11 Compiler tool compiled class files are stored in \fyicenter\jdk-11.0.1\jmods\jdk.compiler.jmod.

JDK 11 Compiler tool compiled class files are also linked and stored in the \fyicenter\jdk-11.0.1\lib\modules JImage file.

JDK 11 Compiler source code files are stored in \fyicenter\jdk-11.0.1\lib\src.zip\jdk.compiler.

You can click and view the content of each source code file in the list below.

✍: FYIcenter

com/sun/tools/javac/api/ClientCodeWrapper.java

/*
 * Copyright (c) 2011, 2017, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */

package com.sun.tools.javac.api;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.Reader;
import java.io.Writer;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.net.URI;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Objects;
import java.util.Set;

import javax.lang.model.element.Modifier;
import javax.lang.model.element.NestingKind;
import javax.tools.Diagnostic;
import javax.tools.DiagnosticListener;
import javax.tools.FileObject;
import javax.tools.JavaFileManager;
import javax.tools.JavaFileManager.Location;
import javax.tools.JavaFileObject;
import javax.tools.JavaFileObject.Kind;
import javax.tools.StandardJavaFileManager;

import com.sun.source.util.TaskEvent;
import com.sun.source.util.TaskListener;
import com.sun.tools.javac.util.ClientCodeException;
import com.sun.tools.javac.util.Context;
import com.sun.tools.javac.util.DefinedBy;
import com.sun.tools.javac.util.DefinedBy.Api;
import com.sun.tools.javac.util.JCDiagnostic;

/**
 *  Wrap objects to enable unchecked exceptions to be caught and handled.
 *
 *  For each method, exceptions are handled as follows:
 *  <ul>
 *  <li>Checked exceptions are left alone and propogate upwards in the
 *      obvious way, since they are an expected aspect of the method's
 *      specification.
 *  <li>Unchecked exceptions which have already been caught and wrapped in
 *      ClientCodeException are left alone to continue propogating upwards.
 *  <li>All other unchecked exceptions (i.e. subtypes of RuntimeException
 *      and Error) and caught, and rethrown as a ClientCodeException with
 *      its cause set to the original exception.
 *  </ul>
 *
 *  The intent is that ClientCodeException can be caught at an appropriate point
 *  in the program and can be distinguished from any unanticipated unchecked
 *  exceptions arising in the main body of the code (i.e. bugs.) When the
 *  ClientCodeException has been caught, either a suitable message can be
 *  generated, or if appropriate, the original cause can be rethrown.
 *
 *  <p><b>This is NOT part of any supported API.
 *  If you write code that depends on this, you do so at your own risk.
 *  This code and its internal interfaces are subject to change or
 *  deletion without notice.</b>
 */
public class ClientCodeWrapper {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.TYPE)
    public @interface Trusted { }

    public static ClientCodeWrapper instance(Context context) {
        ClientCodeWrapper instance = context.get(ClientCodeWrapper.class);
        if (instance == null)
            instance = new ClientCodeWrapper(context);
        return instance;
    }

    /**
     * A map to cache the results of whether or not a specific classes can
     * be "trusted", and thus does not need to be wrapped.
     */
    Map<Class<?>, Boolean> trustedClasses;

    protected ClientCodeWrapper(Context context) {
        trustedClasses = new HashMap<>();
    }

    public JavaFileManager wrap(JavaFileManager fm) {
        if (isTrusted(fm))
            return fm;
        if (fm instanceof StandardJavaFileManager)
            return new WrappedStandardJavaFileManager((StandardJavaFileManager) fm);
        return new WrappedJavaFileManager(fm);
    }

    public FileObject wrap(FileObject fo) {
        if (fo == null || isTrusted(fo))
            return fo;
        return new WrappedFileObject(fo);
    }

    FileObject unwrap(FileObject fo) {
        if (fo instanceof WrappedFileObject)
            return ((WrappedFileObject) fo).clientFileObject;
        else
            return fo;
    }

    public JavaFileObject wrap(JavaFileObject fo) {
        if (fo == null || isTrusted(fo))
            return fo;
        return new WrappedJavaFileObject(fo);
    }

    public Iterable<JavaFileObject> wrapJavaFileObjects(Iterable<? extends JavaFileObject> list) {
        List<JavaFileObject> wrapped = new ArrayList<>();
        for (JavaFileObject fo : list)
            wrapped.add(wrap(fo));
        return Collections.unmodifiableList(wrapped);
    }

    JavaFileObject unwrap(JavaFileObject fo) {
        if (fo instanceof WrappedJavaFileObject)
            return ((JavaFileObject) ((WrappedJavaFileObject) fo).clientFileObject);
        else
            return fo;
    }

    public <T /*super JavaFileOject*/> DiagnosticListener<T> wrap(DiagnosticListener<T> dl) {
        if (isTrusted(dl))
            return dl;
        return new WrappedDiagnosticListener<>(dl);
    }

    TaskListener wrap(TaskListener tl) {
        if (isTrusted(tl))
            return tl;
        return new WrappedTaskListener(tl);
    }

    TaskListener unwrap(TaskListener l) {
        if (l instanceof WrappedTaskListener)
            return ((WrappedTaskListener) l).clientTaskListener;
        else
            return l;
    }

    Collection<TaskListener> unwrap(Collection<? extends TaskListener> listeners) {
        Collection<TaskListener> c = new ArrayList<>(listeners.size());
        for (TaskListener l: listeners)
            c.add(unwrap(l));
        return c;
    }

    @SuppressWarnings("unchecked")
    private <T> Diagnostic<T> unwrap(final Diagnostic<T> diagnostic) {
        if (diagnostic instanceof JCDiagnostic) {
            JCDiagnostic d = (JCDiagnostic) diagnostic;
            return (Diagnostic<T>) new DiagnosticSourceUnwrapper(d);
        } else {
            return diagnostic;
        }
    }

    protected boolean isTrusted(Object o) {
        Class<?> c = o.getClass();
        Boolean trusted = trustedClasses.get(c);
        if (trusted == null) {
            trusted = c.getName().startsWith("com.sun.tools.javac.")
                    || c.isAnnotationPresent(Trusted.class);
            trustedClasses.put(c, trusted);
        }
        return trusted;
    }

    private String wrappedToString(Class<?> wrapperClass, Object wrapped) {
        return wrapperClass.getSimpleName() + "[" + wrapped + "]";
    }

    // <editor-fold defaultstate="collapsed" desc="Wrapper classes">

    protected class WrappedJavaFileManager implements JavaFileManager {
        protected JavaFileManager clientJavaFileManager;
        WrappedJavaFileManager(JavaFileManager clientJavaFileManager) {
            this.clientJavaFileManager = Objects.requireNonNull(clientJavaFileManager);
        }

        @Override @DefinedBy(Api.COMPILER)
        public ClassLoader getClassLoader(Location location) {
            try {
                return clientJavaFileManager.getClassLoader(location);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<JavaFileObject> list(Location location, String packageName, Set<Kind> kinds, boolean recurse) throws IOException {
            try {
                return wrapJavaFileObjects(clientJavaFileManager.list(location, packageName, kinds, recurse));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public String inferBinaryName(Location location, JavaFileObject file) {
            try {
                return clientJavaFileManager.inferBinaryName(location, unwrap(file));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public boolean isSameFile(FileObject a, FileObject b) {
            try {
                return clientJavaFileManager.isSameFile(unwrap(a), unwrap(b));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public boolean handleOption(String current, Iterator<String> remaining) {
            try {
                return clientJavaFileManager.handleOption(current, remaining);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public boolean hasLocation(Location location) {
            try {
                return clientJavaFileManager.hasLocation(location);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public JavaFileObject getJavaFileForInput(Location location, String className, Kind kind) throws IOException {
            try {
                return wrap(clientJavaFileManager.getJavaFileForInput(location, className, kind));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public JavaFileObject getJavaFileForOutput(Location location, String className, Kind kind, FileObject sibling) throws IOException {
            try {
                return wrap(clientJavaFileManager.getJavaFileForOutput(location, className, kind, unwrap(sibling)));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public FileObject getFileForInput(Location location, String packageName, String relativeName) throws IOException {
            try {
                return wrap(clientJavaFileManager.getFileForInput(location, packageName, relativeName));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public FileObject getFileForOutput(Location location, String packageName, String relativeName, FileObject sibling) throws IOException {
            try {
                return wrap(clientJavaFileManager.getFileForOutput(location, packageName, relativeName, unwrap(sibling)));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public boolean contains(Location location, FileObject file) throws IOException {
            try {
                return clientJavaFileManager.contains(location, unwrap(file));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public void flush() throws IOException {
            try {
                clientJavaFileManager.flush();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public void close() throws IOException {
            try {
                clientJavaFileManager.close();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Location getLocationForModule(Location location, String moduleName) throws IOException {
            try {
                return clientJavaFileManager.getLocationForModule(location, moduleName);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Location getLocationForModule(Location location, JavaFileObject fo) throws IOException {
            try {
                return clientJavaFileManager.getLocationForModule(location, unwrap(fo));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public String inferModuleName(Location location) throws IOException {
            try {
                return clientJavaFileManager.inferModuleName(location);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<Set<Location>> listLocationsForModules(Location location) throws IOException {
            try {
                return clientJavaFileManager.listLocationsForModules(location);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public int isSupportedOption(String option) {
            try {
                return clientJavaFileManager.isSupportedOption(option);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override
        public String toString() {
            return wrappedToString(getClass(), clientJavaFileManager);
        }
    }

    protected class WrappedStandardJavaFileManager extends WrappedJavaFileManager
            implements StandardJavaFileManager {
        WrappedStandardJavaFileManager(StandardJavaFileManager clientJavaFileManager) {
            super(clientJavaFileManager);
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromFiles(Iterable<? extends File> files) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getJavaFileObjectsFromFiles(files);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromPaths(Iterable<? extends Path> paths) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getJavaFileObjectsFromPaths(paths);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends JavaFileObject> getJavaFileObjects(File... files) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getJavaFileObjects(files);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends JavaFileObject> getJavaFileObjects(Path... paths) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getJavaFileObjects(paths);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends JavaFileObject> getJavaFileObjectsFromStrings(Iterable<String> names) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getJavaFileObjectsFromStrings(names);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends JavaFileObject> getJavaFileObjects(String... names) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getJavaFileObjects(names);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public void setLocation(Location location, Iterable<? extends File> files) throws IOException {
            try {
                ((StandardJavaFileManager)clientJavaFileManager).setLocation(location, files);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public void setLocationFromPaths(Location location, Collection<? extends Path> paths) throws IOException {
            try {
                ((StandardJavaFileManager)clientJavaFileManager).setLocationFromPaths(location, paths);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends File> getLocation(Location location) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getLocation(location);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Iterable<? extends Path> getLocationAsPaths(Location location) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).getLocationAsPaths(location);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Path asPath(FileObject file) {
            try {
                return ((StandardJavaFileManager)clientJavaFileManager).asPath(file);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public void setPathFactory(PathFactory f) {
            try {
                ((StandardJavaFileManager)clientJavaFileManager).setPathFactory(f);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }
    }

    protected class WrappedFileObject implements FileObject {
        protected FileObject clientFileObject;
        WrappedFileObject(FileObject clientFileObject) {
            this.clientFileObject = Objects.requireNonNull(clientFileObject);
        }

        @Override @DefinedBy(Api.COMPILER)
        public URI toUri() {
            try {
                return clientFileObject.toUri();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public String getName() {
            try {
                return clientFileObject.getName();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public InputStream openInputStream() throws IOException {
            try {
                return clientFileObject.openInputStream();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public OutputStream openOutputStream() throws IOException {
            try {
                return clientFileObject.openOutputStream();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Reader openReader(boolean ignoreEncodingErrors) throws IOException {
            try {
                return clientFileObject.openReader(ignoreEncodingErrors);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public CharSequence getCharContent(boolean ignoreEncodingErrors) throws IOException {
            try {
                return clientFileObject.getCharContent(ignoreEncodingErrors);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Writer openWriter() throws IOException {
            try {
                return clientFileObject.openWriter();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public long getLastModified() {
            try {
                return clientFileObject.getLastModified();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public boolean delete() {
            try {
                return clientFileObject.delete();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override
        public String toString() {
            return wrappedToString(getClass(), clientFileObject);
        }
    }

    protected class WrappedJavaFileObject extends WrappedFileObject implements JavaFileObject {
        WrappedJavaFileObject(JavaFileObject clientJavaFileObject) {
            super(clientJavaFileObject);
        }

        @Override @DefinedBy(Api.COMPILER)
        public Kind getKind() {
            try {
                return ((JavaFileObject)clientFileObject).getKind();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public boolean isNameCompatible(String simpleName, Kind kind) {
            try {
                return ((JavaFileObject)clientFileObject).isNameCompatible(simpleName, kind);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public NestingKind getNestingKind() {
            try {
                return ((JavaFileObject)clientFileObject).getNestingKind();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER)
        public Modifier getAccessLevel() {
            try {
                return ((JavaFileObject)clientFileObject).getAccessLevel();
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override
        public String toString() {
            return wrappedToString(getClass(), clientFileObject);
        }
    }

    protected class WrappedDiagnosticListener<T /*super JavaFileObject*/> implements DiagnosticListener<T> {
        protected DiagnosticListener<T> clientDiagnosticListener;
        WrappedDiagnosticListener(DiagnosticListener<T> clientDiagnosticListener) {
            this.clientDiagnosticListener = Objects.requireNonNull(clientDiagnosticListener);
        }

        @Override @DefinedBy(Api.COMPILER)
        public void report(Diagnostic<? extends T> diagnostic) {
            try {
                clientDiagnosticListener.report(unwrap(diagnostic));
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override
        public String toString() {
            return wrappedToString(getClass(), clientDiagnosticListener);
        }
    }

    public class DiagnosticSourceUnwrapper implements Diagnostic<JavaFileObject> {
        public final JCDiagnostic d;

        DiagnosticSourceUnwrapper(JCDiagnostic d) {
            this.d = d;
        }

        @Override @DefinedBy(Api.COMPILER)
        public Diagnostic.Kind getKind() {
            return d.getKind();
        }

        @Override @DefinedBy(Api.COMPILER)
        public JavaFileObject getSource() {
            return unwrap(d.getSource());
        }

        @Override @DefinedBy(Api.COMPILER)
        public long getPosition() {
            return d.getPosition();
        }

        @Override @DefinedBy(Api.COMPILER)
        public long getStartPosition() {
            return d.getStartPosition();
        }

        @Override @DefinedBy(Api.COMPILER)
        public long getEndPosition() {
            return d.getEndPosition();
        }

        @Override @DefinedBy(Api.COMPILER)
        public long getLineNumber() {
            return d.getLineNumber();
        }

        @Override @DefinedBy(Api.COMPILER)
        public long getColumnNumber() {
            return d.getColumnNumber();
        }

        @Override @DefinedBy(Api.COMPILER)
        public String getCode() {
            return d.getCode();
        }

        @Override @DefinedBy(Api.COMPILER)
        public String getMessage(Locale locale) {
            return d.getMessage(locale);
        }

        @Override
        public String toString() {
            return d.toString();
        }
    }

    protected class WrappedTaskListener implements TaskListener {
        protected TaskListener clientTaskListener;
        WrappedTaskListener(TaskListener clientTaskListener) {
            this.clientTaskListener = Objects.requireNonNull(clientTaskListener);
        }

        @Override @DefinedBy(Api.COMPILER_TREE)
        public void started(TaskEvent ev) {
            try {
                clientTaskListener.started(ev);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override @DefinedBy(Api.COMPILER_TREE)
        public void finished(TaskEvent ev) {
            try {
                clientTaskListener.finished(ev);
            } catch (ClientCodeException e) {
                throw e;
            } catch (RuntimeException | Error e) {
                throw new ClientCodeException(e);
            }
        }

        @Override
        public String toString() {
            return wrappedToString(getClass(), clientTaskListener);
        }
    }

    // </editor-fold>
}

com/sun/tools/javac/api/ClientCodeWrapper.java

 

JDK 11 jdk.crypto.cryptoki.jmod - Crypto KI Module

JDK 11 jdk.charsets.jmod - Charsets Module

Download and Use JDK 11

⇑⇑ FAQ for JDK (Java Development Kit)

2018-11-09, 7469👍, 0💬