Java Code Examples for javax.tools.JavaFileManager

void clear() {
    drop(Arguments.argsKey);
    drop(DiagnosticListener.class);
    drop(Log.outKey);
    drop(Log.errKey);
    drop(JavaFileManager.class);
    drop(JavacTask.class);

    if (ht.get(Log.logKey) instanceof ReusableLog) {
        //log already inited - not first round
        ((ReusableLog)Log.instance(this)).clear();
        Enter.instance(this).newRound();
        ((ReusableJavaCompiler)ReusableJavaCompiler.instance(this)).clear();
        Types.instance(this).newRound();
        Check.instance(this).newRound();
        Modules.instance(this).newRound();
        Annotate.instance(this).newRound();
        CompileStates.instance(this).clear();
        MultiTaskListener.instance(this).clear();

        //find if any of the roots have redefined java.* classes
        Symtab syms = Symtab.instance(this);
        pollutionScanner.scan(roots, syms);
        roots.clear();
    }
}
 

private void init(Context context) {
    modules = Modules.instance(context);
    attr = Attr.instance(context);
    enter = Enter.instance(context);
    elements = JavacElements.instance(context);
    log = Log.instance(context);
    resolve = Resolve.instance(context);
    treeMaker = TreeMaker.instance(context);
    memberEnter = MemberEnter.instance(context);
    names = Names.instance(context);
    types = Types.instance(context);
    docTreeMaker = DocTreeMaker.instance(context);
    parser = ParserFactory.instance(context);
    syms = Symtab.instance(context);
    fileManager = context.get(JavaFileManager.class);
    JavacTask t = context.get(JavacTask.class);
    if (t instanceof JavacTaskImpl)
        javacTaskImpl = (JavacTaskImpl) t;
}
 

private void initProcessorClassLoader() {
    JavaFileManager fileManager = context.get(JavaFileManager.class);
    try {
        // If processorpath is not explicitly set, use the classpath.
        processorClassLoader = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
            ? fileManager.getClassLoader(ANNOTATION_PROCESSOR_PATH)
            : fileManager.getClassLoader(CLASS_PATH);

        if (processorClassLoader != null && processorClassLoader instanceof Closeable) {
            JavaCompiler compiler = JavaCompiler.instance(context);
            compiler.closeables = compiler.closeables.prepend((Closeable) processorClassLoader);
        }
    } catch (SecurityException e) {
        processorClassLoaderException = e;
    }
}
 

private void runMethod(String code) throws IOException {
    String src = prefix +
            code + "}" +
            postfix;

    try (JavaFileManager fm = tool.getStandardFileManager(null, null, null)) {
        JavacTaskImpl ct = (JavacTaskImpl) tool.getTask(null, fm, null, null,
                null, Arrays.asList(new MyFileObject(src)));


        for (CompilationUnitTree cut : ct.parse()) {
            JCTree.JCMethodDecl meth =
                    (JCTree.JCMethodDecl) ((ClassTree) cut.getTypeDecls().get(0)).getMembers().get(0);
            checkMatch(code, meth);
        }
    }
}
 

/**
 * Returns an empty processor iterator if no processors are on the
 * relevant path, otherwise if processors are present, logs an
 * error.  Called when a service loader is unavailable for some
 * reason, either because a service loader class cannot be found
 * or because a security policy prevents class loaders from being
 * created.
 *
 * @param key The resource key to use to log an error message
 * @param e   If non-null, pass this exception to Abort
 */
private Iterator<Processor> handleServiceLoaderUnavailability(String key, Exception e) {
    JavaFileManager fileManager = context.get(JavaFileManager.class);

    if (fileManager instanceof JavacFileManager) {
        StandardJavaFileManager standardFileManager = (JavacFileManager) fileManager;
        Iterable<? extends File> workingPath = fileManager.hasLocation(ANNOTATION_PROCESSOR_PATH)
            ? standardFileManager.getLocation(ANNOTATION_PROCESSOR_PATH)
            : standardFileManager.getLocation(CLASS_PATH);

        if (needClassLoader(options.get(PROCESSOR), workingPath) )
            handleException(key, e);

    } else {
        handleException(key, e);
    }

    java.util.List<Processor> pl = Collections.emptyList();
    return pl.iterator();
}
 

private void run() {
    File classToCheck = new File(System.getProperty("test.classes"),
        getClass().getSimpleName() + ".class");

    DiagnosticCollector<JavaFileObject> dc =
            new DiagnosticCollector<JavaFileObject>();
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    JavaFileManager fm = JavapFileManager.create(dc, pw);
    JavapTask t = new JavapTask(pw, fm, dc, null,
            Arrays.asList(classToCheck.getPath()));
    if (t.run() != 0)
        throw new Error("javap failed unexpectedly");

    List<Diagnostic<? extends JavaFileObject>> diags = dc.getDiagnostics();
    for (Diagnostic<? extends JavaFileObject> d: diags) {
        if (d.getKind() == Diagnostic.Kind.ERROR)
            throw new AssertionError(d.getMessage(Locale.ENGLISH));
    }
    String lineSep = System.getProperty("line.separator");
    String out = sw.toString().replace(lineSep, "\n");
    if (!out.equals(expOutput)) {
        throw new AssertionError("The output is not equal to the one expected");
    }
}
 

private String javap(List<String> args, List<String> classes) {
    DiagnosticCollector<JavaFileObject> dc = new DiagnosticCollector<JavaFileObject>();
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    JavaFileManager fm = JavapFileManager.create(dc, pw);
    JavapTask t = new JavapTask(pw, fm, dc, args, classes);
    if (t.run() != 0)
        throw new Error("javap failed unexpectedly");

    List<Diagnostic<? extends JavaFileObject>> diags = dc.getDiagnostics();
    for (Diagnostic<? extends JavaFileObject> d: diags) {
        if (d.getKind() == Diagnostic.Kind.ERROR)
            throw new Error(d.getMessage(Locale.ENGLISH));
    }
    return sw.toString();

}
 

private void run() {
    File classToCheck = new File(System.getProperty("test.classes"),
        getClass().getSimpleName() + ".class");

    DiagnosticCollector<JavaFileObject> dc =
            new DiagnosticCollector<JavaFileObject>();
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    JavaFileManager fm = JavapFileManager.create(dc, pw);
    JavapTask t = new JavapTask(pw, fm, dc, null,
            Arrays.asList(classToCheck.getPath()));
    if (t.run() != 0)
        throw new Error("javap failed unexpectedly");

    List<Diagnostic<? extends JavaFileObject>> diags = dc.getDiagnostics();
    for (Diagnostic<? extends JavaFileObject> d: diags) {
        if (d.getKind() == Diagnostic.Kind.ERROR)
            throw new AssertionError(d.getMessage(Locale.ENGLISH));
    }
    String lineSep = System.getProperty("line.separator");
    String out = sw.toString().replace(lineSep, "\n");
    if (!out.equals(expOutput)) {
        throw new AssertionError("The output is not equal to the one expected");
    }
}
 

JavahTask(Writer out,
        JavaFileManager fileManager,
        DiagnosticListener<? super JavaFileObject> diagnosticListener,
        Iterable<String> options,
        Iterable<String> classes) {
    this();
    this.log = getPrintWriterForWriter(out);
    this.fileManager = fileManager;
    this.diagnosticListener = diagnosticListener;

    try {
        handleOptions(options, false);
    } catch (BadArgs e) {
        throw new IllegalArgumentException(e.getMessage());
    }

    this.classes = new ArrayList<String>();
    if (classes != null) {
        for (String classname: classes) {
            classname.getClass(); // null-check
            this.classes.add(classname);
        }
    }
}
 

public UsagesVisitor (
        @NonNull final JavacTaskImpl jt,
        @NonNull final CompilationUnitTree cu,
        @NonNull final JavaFileManager manager,
        @NonNull final javax.tools.JavaFileObject sibling,
        @NullAllowed final Set<? super ElementHandle<TypeElement>> newTypes,
        @NullAllowed final Set<? super ElementHandle<ModuleElement>> newModules,
        final JavaCustomIndexer.CompileTuple tuple) throws MalformedURLException, IllegalArgumentException {
    this(
            jt,
            cu,
            inferBinaryName(manager, sibling),
            tuple.virtual ? tuple.indexable.getURL() : sibling.toUri().toURL(),
            true,
            tuple.virtual,
            newTypes,
            newModules,
            null);
}
 

private InputStream getConfigStream(Optional<Path> configFile, JavaFileManager jfm) {
    try {
        if (configFile.isPresent()) {
            return Files.newInputStream(configFile.get());
        }
        else {
            FileObject file = jfm.getFileForInput(StandardLocation.SOURCE_PATH, "", "deptective.json");

            if (file != null) {
                return file.openInputStream();
            }

            file = jfm.getFileForInput(StandardLocation.CLASS_PATH, "", "META-INF/deptective.json");

            if (file != null) {
                return file.openInputStream();
            }
        }
    }
    catch (IOException e) {
        throw new RuntimeException("Failed to load Deptective configuration file", e);
    }

    return null;
}
 

public JavapTask(Writer out,
        JavaFileManager fileManager,
        DiagnosticListener<? super JavaFileObject> diagnosticListener,
        Iterable<String> options,
        Iterable<String> classes) {
    this(out, fileManager, diagnosticListener);

    this.classes = new ArrayList<String>();
    for (String classname: classes) {
        classname.getClass(); // null-check
        this.classes.add(classname);
    }

    try {
        if (options != null)
            handleOptions(options, false);
    } catch (BadArgs e) {
        throw new IllegalArgumentException(e.getMessage());
    }
}
 

@NonNull
JavaFileManager[] get() {
    JavaFileManager[] res;
     if (fileManagers != null) {
        res = fileManagers;
    } else {
        fileManagers = factory.get();
        assert fileManagers != null;
        factory = null;
        res = fileManagers;
    }
    if (filter != null) {
        res = filter.apply(res);
    }
    return res;
}
 

private String javap(List<String> args, List<String> classes) {
    DiagnosticCollector<JavaFileObject> dc = new DiagnosticCollector<JavaFileObject>();
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    JavaFileManager fm = JavapFileManager.create(dc, pw);
    JavapTask t = new JavapTask(pw, fm, dc, args, classes);
    if (t.run() != 0)
        throw new Error("javap failed unexpectedly");

    List<Diagnostic<? extends JavaFileObject>> diags = dc.getDiagnostics();
    for (Diagnostic<? extends JavaFileObject> d: diags) {
        if (d.getKind() == Diagnostic.Kind.ERROR)
            throw new Error(d.getMessage(Locale.ENGLISH));
    }
    return sw.toString();

}
 

private String javap(List<String> args, List<String> classes) {
    DiagnosticCollector<JavaFileObject> dc = new DiagnosticCollector<JavaFileObject>();
    StringWriter sw = new StringWriter();
    PrintWriter pw = new PrintWriter(sw);
    JavaFileManager fm = JavapFileManager.create(dc, pw);
    JavapTask t = new JavapTask(pw, fm, dc, args, classes);
    if (t.run() != 0)
        throw new Error("javap failed unexpectedly");

    List<Diagnostic<? extends JavaFileObject>> diags = dc.getDiagnostics();
    for (Diagnostic<? extends JavaFileObject> d: diags) {
        if (d.getKind() == Diagnostic.Kind.ERROR)
            throw new Error(d.getMessage(Locale.ENGLISH));
    }
    return sw.toString();

}
 

/**
 * Constructor
 *
 * @param context      Context for this javadoc instance.
 */
protected DocEnv(Context context) {
    context.put(docEnvKey, this);
    this.context = context;

    messager = Messager.instance0(context);
    syms = Symtab.instance(context);
    reader = JavadocClassReader.instance0(context);
    enter = JavadocEnter.instance0(context);
    names = Names.instance(context);
    externalizableSym = reader.enterClass(names.fromString("java.io.Externalizable"));
    chk = Check.instance(context);
    types = Types.instance(context);
    fileManager = context.get(JavaFileManager.class);
    if (fileManager instanceof JavacFileManager) {
        ((JavacFileManager)fileManager).setSymbolFileEnabled(false);
    }

    // Default.  Should normally be reset with setLocale.
    this.doclocale = new DocLocale(this, "", breakiterator);
    source = Source.instance(context);
}
 

/**
 * Analyzes given compilation unit and returns the result of analyzes.
 * @param cu the java compilation unit to be analyzed
 * @param jt the {@link JavacTaskImpl} providing the context
 * @param manager the {@link JavaFileManager} used to infer binary names
 * @return the result of analyzes encoded as list of tuples {{fqn,relative_source_path_or_null},usages_data}
 * @throws IOException in case of IO error
 */
@CheckForNull
public List<Pair<Pair<BinaryName, String>, Object[]>> analyseUnit (
        @NonNull final CompilationUnitTree cu,
        @NonNull final JavacTaskImpl jt) throws IOException {
    if (used) {
        throw new IllegalStateException("Trying to reuse SimpleAnalyzer");  //NOI18N
    }
    used = true;
    try {
        final Map<Pair<BinaryName,String>,UsagesData<String>> usages = new HashMap<> ();
        final Set<Pair<String,String>> topLevels = new HashSet<>();
        final JavaFileManager jfm = jt.getContext().get(JavaFileManager.class);
        final UsagesVisitor uv = new UsagesVisitor (jt, cu, jfm, cu.getSourceFile(), topLevels);
        uv.scan(cu,usages);
        for (Map.Entry<Pair<BinaryName,String>,UsagesData<String>> oe : usages.entrySet()) {
            final Pair<BinaryName,String> key = oe.getKey();
            final UsagesData<String> data = oe.getValue();
            addClassReferences (key,data);
        }
        //this.writer.deleteEnclosedAndStore(this.references, topLevels);
        return this.references;
    } catch (IllegalArgumentException iae) {
        Exceptions.printStackTrace(iae);
        return null;
    }catch (OutputFileManager.InvalidSourcePath e) {
        return null;
    }
}
 

void test_setPaths_getPaths(StandardJavaFileManager fm, List<Path> inPaths) throws IOException {
    System.err.println("test_setPaths_getPaths");
    JavaFileManager.Location l = newLocation();
    fm.setLocationFromPaths(l, inPaths);
    Iterable<? extends Path> outPaths = fm.getLocationAsPaths(l);
    compare(inPaths, outPaths);
}
 

/**
 * Get the appropriate factory, based on the file manager given in the
 * configuration.
 *
 * @param configuration the configuration for this doclet
 * @return the factory associated with this configuration
 */
public static synchronized DocFileFactory getFactory(Configuration configuration) {
    DocFileFactory f = configuration.docFileFactory;
    if (f == null) {
        JavaFileManager fm = configuration.getFileManager();
        if (fm instanceof StandardJavaFileManager) {
            f = new StandardDocFileFactory(configuration);
        } else {
            throw new IllegalStateException();
        }
        configuration.docFileFactory = f;
    }
    return f;
}
 

/**
 * Create a JavacPathFileManager using a given context, optionally registering
 * it as the JavaFileManager for that context.
 */
public JavacPathFileManager(Context context, boolean register, Charset charset) {
    super(charset);
    if (register)
        context.put(JavaFileManager.class, this);
    pathsForLocation = new HashMap<Location, PathsForLocation>();
    fileSystems = new HashMap<Path,FileSystem>();
    setContext(context);
}
 

@Override
public DocumentationTask getTask(
        Writer out,
        JavaFileManager fileManager,
        DiagnosticListener<? super JavaFileObject> diagnosticListener,
        Class<?> docletClass,
        Iterable<String> options,
        Iterable<? extends JavaFileObject> compilationUnits) {
    Context context = new Context();
    return getTask(out, fileManager, diagnosticListener,
            docletClass, options, compilationUnits, context);
}
 

/**
 * exclusive to top-level types (facilitates inner class extensions)
 */
@Override
public void prepareToRender( JavaFileManager.Location location, IModule module, DiagnosticListener<JavaFileObject> errorHandler )
{
  _state._location = location;
  _state._module = module;
  _state._errorHandler = errorHandler;
}
 

/**
 * Prepare the compiler thread for use. It is not yet started.
 * It will be started by the executor service.
 */
public synchronized void use() {
    assert(!inUse);
    inUse = true;
    compiler = com.sun.tools.javac.api.JavacTool.create();
    fileManager = compiler.getStandardFileManager(null, null, null);
    fileManagerBase = (BaseFileManager)fileManager;
    smartFileManager = new SmartFileManager(fileManager);
    context = new Context();
    context.put(JavaFileManager.class, smartFileManager);
    ResolveWithDeps.preRegister(context);
    JavaCompilerWithDeps.preRegister(context, this);
    subTasks = new ArrayList<Future<?>>();
}
 

/**
 * Prepare the compiler thread for use. It is not yet started.
 * It will be started by the executor service.
 */
public synchronized void use() {
    assert(!inUse);
    inUse = true;
    compiler = com.sun.tools.javac.api.JavacTool.create();
    fileManager = compiler.getStandardFileManager(null, null, null);
    fileManagerBase = (BaseFileManager)fileManager;
    smartFileManager = new SmartFileManager(fileManager);
    context = new Context();
    context.put(JavaFileManager.class, smartFileManager);
    ResolveWithDeps.preRegister(context);
    JavaCompilerWithDeps.preRegister(context, this);
    subTasks = new ArrayList<Future<?>>();
}
 

/**
 * Prepare the compiler thread for use. It is not yet started.
 * It will be started by the executor service.
 */
public synchronized void use() {
    assert(!inUse);
    inUse = true;
    compiler = com.sun.tools.javac.api.JavacTool.create();
    fileManager = compiler.getStandardFileManager(null, null, null);
    fileManagerBase = (BaseFileManager)fileManager;
    smartFileManager = new SmartFileManager(fileManager);
    context = new Context();
    context.put(JavaFileManager.class, smartFileManager);
    ResolveWithDeps.preRegister(context);
    JavaCompilerWithDeps.preRegister(context, this);
    subTasks = new ArrayList<Future<?>>();
}
 

@Override
public ClasspathInfo create (
        @NonNull final ClassPath bootPath,
        @NonNull final ClassPath moduleBootPath,
        @NonNull final ClassPath classPath,
        @NonNull final ClassPath moduleCompilePath,
        @NonNull final ClassPath moduleClassPath,
        @NullAllowed final ClassPath sourcePath,
        @NullAllowed final ClassPath moduleSourcePath,
        @NullAllowed final JavaFileFilterImplementation filter,
        final boolean backgroundCompilation,
        final boolean ignoreExcludes,
        final boolean hasMemoryFileManager,
        final boolean useModifiedFiles,
        final boolean requiresSourceRoots,
        @NullAllowed final Function<JavaFileManager.Location, JavaFileManager> jfmProvider) {
    return ClasspathInfo.create(
            bootPath,
            moduleBootPath,
            classPath,
            moduleCompilePath,
            moduleClassPath,
            sourcePath,
            moduleSourcePath,
            filter,
            backgroundCompilation,
            ignoreExcludes,
            hasMemoryFileManager,
            useModifiedFiles,
            requiresSourceRoots,
            jfmProvider);
}
 

@Override
public FileObject createResource(
    JavaFileManager.Location location,
    CharSequence pkg,
    CharSequence relativeName,
    Element... originatingElements)
    throws IOException {
  return delegate.createResource(location, pkg, relativeName, originatingElements);
}
 

SourceClassLoader(
    ClassLoader parent,
    JavaFileManager fileManager,
    Set<String> testFiles) {
  super(parent);
  this.fileManager = fileManager;
  this.testFiles = testFiles;
}
 

static private boolean compile(Iterable<? extends Processor> processors) {
  JavaCompiler compiler = new EclipseCompiler();
  DiagnosticCollector<JavaFileObject> diagnosticCollector =
      new DiagnosticCollector<>();
  JavaFileManager fileManager = compiler.getStandardFileManager(diagnosticCollector, Locale.getDefault(), UTF_8);
  JavaCompiler.CompilationTask task = compiler.getTask(
      null,
      fileManager,
      diagnosticCollector,
      ImmutableSet.of(),
      ImmutableSet.of(TypesEclipseTest.class.getCanonicalName()),
      ImmutableSet.of());
  task.setProcessors(processors);
  return task.call();
}
 

@SuppressWarnings("WeakerAccess")
public String inferBinaryName( JavaFileManager.Location location )
{
  if( _fqn == null )
  {
    throw new IllegalStateException( "Null class name" );
  }
  return _fqn;
}