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.

⏎ com/sun/tools/sjavac/Source.java

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

package com.sun.tools.sjavac;

import java.io.File;
import java.io.IOException;
import java.nio.file.FileSystem;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.PathMatcher;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.Set;
import java.util.Collections;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.regex.PatternSyntaxException;

/** A Source object maintains information about a source file.
 * For example which package it belongs to and kind of source it is.
 * The class also knows how to find source files (scanRoot) given include/exclude
 * patterns and a root.
 *
 *  <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 Source implements Comparable<Source> {
    // The package the source belongs to.
   private Package pkg;
    // Name of this source file, relative its source root.
    // For example: java/lang/Object.java
    // Or if the source file is inside a module:
    // jdk.base/java/lang/Object.java
    private String name;
    // What kind of file is this.
    private String suffix;
    // When this source file was last_modified
    private long lastModified;
    // The source File.
    private File file;
    // If the source is generated.
    private boolean isGenerated;
    // If the source is only linked to, not compiled.
    private boolean linkedOnly;

    @Override
    public boolean equals(Object o) {
        return (o instanceof Source) && name.equals(((Source)o).name);
    }

    @Override
    public int compareTo(Source o) {
        return name.compareTo(o.name);
    }

    @Override
    public int hashCode() {
        return name.hashCode();
    }

    public Source(Module m, String n, File f) {
        name = n;
        int dp = n.lastIndexOf(".");
        if (dp != -1) {
            suffix = n.substring(dp);
        } else {
            suffix = "";
        }
        file = f;
        lastModified = f.lastModified();
        linkedOnly = false;
    }

    public Source(Package p, String n, long lm) {
        pkg = p;
        name = n;
        int dp = n.lastIndexOf(".");
        if (dp != -1) {
            suffix = n.substring(dp);
        } else {
            suffix = "";
        }
        file = null;
        lastModified = lm;
        linkedOnly = false;
        int ls = n.lastIndexOf('/');
    }

    public String name() { return name; }
    public String suffix() { return suffix; }
    public Package pkg() { return pkg; }
    public File   file() { return file; }
    public long lastModified() {
        return lastModified;
    }

    public void setPackage(Package p) {
        pkg = p;
    }

    public void markAsGenerated() {
        isGenerated = true;
    }

    public boolean isGenerated() {
        return isGenerated;
    }

    public void markAsLinkedOnly() {
        linkedOnly = true;
    }

    public boolean isLinkedOnly() {
        return linkedOnly;
    }

    private void save(StringBuilder b) {
        String CL = linkedOnly?"L":"C";
        String GS = isGenerated?"G":"S";
        b.append(GS+" "+CL+" "+name+" "+file.lastModified()+"\n");
    }
    // Parse a line that looks like this:
    // S C /code/alfa/A.java 1357631228000
    static public Source load(Package lastPackage, String l, boolean isGenerated) {
        int sp = l.indexOf(' ',4);
        if (sp == -1) return null;
        String name = l.substring(4,sp);
        long last_modified = Long.parseLong(l.substring(sp+1));

        boolean isLinkedOnly = false;
        if (l.charAt(2) == 'L') {
            isLinkedOnly = true;
        } else if (l.charAt(2) == 'C') {
            isLinkedOnly = false;
        } else return null;

        Source s = new Source(lastPackage, name, last_modified);
        s.file = new File(name);
        if (isGenerated) s.markAsGenerated();
        if (isLinkedOnly) s.markAsLinkedOnly();
        return s;
    }

    public static void saveSources(Map<String,Source> sources, StringBuilder b) {
        List<String> sorted_sources = new ArrayList<>();
        for (String key : sources.keySet()) {
            sorted_sources.add(key);
        }
        Collections.sort(sorted_sources);
        for (String key : sorted_sources) {
            Source s = sources.get(key);
            s.save(b);
        }
    }

    /**
     * Recurse into the directory root and find all files matchine the excl/incl/exclfiles/inclfiles rules.
     * Detects the existence of module-info.java files and presumes that the directory it resides in
     * is the name of the current module.
     */
    static public void scanRoot(File root,
                                Set<String> suffixes,
                                List<String> excludes,
                                List<String> includes,
                                Map<String,Source> foundFiles,
                                Map<String,Module> foundModules,
                                final Module currentModule,
                                boolean permitSourcesWithoutPackage,
                                boolean inGensrc,
                                boolean inLinksrc)
                                        throws IOException, ProblemException {

        if (root == null)
            return;

        FileSystem fs = root.toPath().getFileSystem();

        if (includes.isEmpty()) {
            includes = Collections.singletonList("**");
        }

        List<PathMatcher> includeMatchers = createPathMatchers(fs, includes);
        List<PathMatcher> excludeMatchers = createPathMatchers(fs, excludes);

        Files.walkFileTree(root.toPath(), new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {

                Path relToRoot = root.toPath().relativize(file);

                if (includeMatchers.stream().anyMatch(im -> im.matches(relToRoot))
                        && excludeMatchers.stream().noneMatch(em -> em.matches(relToRoot))
                        && suffixes.contains(Util.fileSuffix(file))) {

                    // TODO: Test this.
                    Source existing = foundFiles.get(file);
                    if (existing != null) {
                        throw new IOException("You have already added the file "+file+" from "+existing.file().getPath());
                    }
                    existing = currentModule.lookupSource(file.toString());
                    if (existing != null) {

                            // Oups, the source is already added, could be ok, could be not, lets check.
                            if (inLinksrc) {
                                // So we are collecting sources for linking only.
                                if (existing.isLinkedOnly()) {
                                    // Ouch, this one is also for linking only. Bad.
                                    throw new IOException("You have already added the link only file " + file + " from " + existing.file().getPath());
                                }
                                // Ok, the existing source is to be compiled. Thus this link only is redundant
                                // since all compiled are also linked to. Continue to the next source.
                                // But we need to add the source, so that it will be visible to linking,
                                // if not the multi core compile will fail because a JavaCompiler cannot
                                // find the necessary dependencies for its part of the source.
                                foundFiles.put(file.toString(), existing);
                            } else {
                                // We are looking for sources to compile, if we find an existing to be compiled
                                // source with the same name, it is an internal error, since we must
                                // find the sources to be compiled before we find the sources to be linked to.
                                throw new IOException("Internal error: Double add of file " + file + " from " + existing.file().getPath());
                            }

                    } else {

                        //////////////////////////////////////////////////////////////
                        // Add source
                        Source s = new Source(currentModule, file.toString(), file.toFile());
                        if (inGensrc) {
                            s.markAsGenerated();
                        }
                        if (inLinksrc) {
                            s.markAsLinkedOnly();
                        }
                        String pkg = packageOfJavaFile(root.toPath(), file);
                        pkg = currentModule.name() + ":" + pkg;
                        foundFiles.put(file.toString(), s);
                        currentModule.addSource(pkg, s);
                        //////////////////////////////////////////////////////////////
                    }
                }

                return FileVisitResult.CONTINUE;
            }
        });
    }

    private static List<PathMatcher> createPathMatchers(FileSystem fs, List<String> patterns) {
        List<PathMatcher> matchers = new ArrayList<>();
        for (String pattern : patterns) {
            try {
                matchers.add(fs.getPathMatcher("glob:" + pattern));
            } catch (PatternSyntaxException e) {
                Log.error("Invalid pattern: " + pattern);
                throw e;
            }
        }
        return matchers;
    }

    private static String packageOfJavaFile(Path sourceRoot, Path javaFile) {
        Path javaFileDir = javaFile.getParent();
        Path packageDir = sourceRoot.relativize(javaFileDir);
        List<String> separateDirs = new ArrayList<>();
        for (Path pathElement : packageDir) {
            separateDirs.add(pathElement.getFileName().toString());
        }
        return String.join(".", separateDirs);
    }

    @Override
    public String toString() {
        return String.format("%s[pkg: %s, name: %s, suffix: %s, file: %s, isGenerated: %b, linkedOnly: %b]",
                             getClass().getSimpleName(),
                             pkg,
                             name,
                             suffix,
                             file,
                             isGenerated,
                             linkedOnly);
    }
}

⏎ com/sun/tools/sjavac/Source.java

Or download all of them as a single archive file:

File name: jdk.compiler-11.0.1-src.zip
File size: 1347269 bytes
Release date: 2018-11-04
Download 

⇒ 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)