Examples with StandardJavaFileManager org.eclipse.ceylon.javax.tools.StandardJavaFileManager used on opensource projects

Example 1 with StandardJavaFileManager

use of org.eclipse.ceylon.javax.tools.StandardJavaFileManager in project ceylon by eclipse.

the class ClassReader method fillIn.

/**
 * Load directory of package into members scope.
 */
private void fillIn(PackageSymbol p) throws IOException {
    if (p.members_field == null)
        p.members_field = new Scope(p);
    String packageName = p.fullname.toString();
    Set<JavaFileObject.Kind> kinds = getPackageFileKinds();
    fillIn(p, PLATFORM_CLASS_PATH, fileManager.list(PLATFORM_CLASS_PATH, packageName, EnumSet.of(JavaFileObject.Kind.CLASS), false));
    Set<JavaFileObject.Kind> classKinds = EnumSet.copyOf(kinds);
    classKinds.remove(JavaFileObject.Kind.SOURCE);
    boolean wantClassFiles = !classKinds.isEmpty();
    Set<JavaFileObject.Kind> sourceKinds = EnumSet.copyOf(kinds);
    sourceKinds.remove(JavaFileObject.Kind.CLASS);
    boolean wantSourceFiles = !sourceKinds.isEmpty();
    boolean haveSourcePath = fileManager.hasLocation(SOURCE_PATH);
    if (verbose && verbosePath) {
        if (fileManager instanceof StandardJavaFileManager) {
            StandardJavaFileManager fm = (StandardJavaFileManager) fileManager;
            if (haveSourcePath && wantSourceFiles) {
                List<File> path = List.nil();
                for (File file : fm.getLocation(SOURCE_PATH)) {
                    path = path.prepend(file);
                }
                log.printVerbose("sourcepath", path.reverse().toString());
            } else if (wantSourceFiles) {
                List<File> path = List.nil();
                for (File file : fm.getLocation(CLASS_PATH)) {
                    path = path.prepend(file);
                }
                log.printVerbose("sourcepath", path.reverse().toString());
            }
            if (wantClassFiles) {
                List<File> path = List.nil();
                for (File file : fm.getLocation(PLATFORM_CLASS_PATH)) {
                    path = path.prepend(file);
                }
                for (File file : fm.getLocation(CLASS_PATH)) {
                    path = path.prepend(file);
                }
                log.printVerbose("classpath", path.reverse().toString());
            }
        }
    }
    if (wantSourceFiles && !haveSourcePath) {
        fillIn(p, CLASS_PATH, fileManager.list(CLASS_PATH, packageName, kinds, false));
    } else {
        if (wantClassFiles)
            fillIn(p, CLASS_PATH, fileManager.list(CLASS_PATH, packageName, classKinds, false));
        if (wantSourceFiles)
            fillIn(p, SOURCE_PATH, fileManager.list(SOURCE_PATH, packageName, sourceKinds, false));
    }
    verbosePath = false;
}

Example 2 with StandardJavaFileManager

use of org.eclipse.ceylon.javax.tools.StandardJavaFileManager in project ceylon by eclipse.

the class JavacProcessingEnvironment method handleServiceLoaderUnavailability.

/**
 * 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();
}

Example 3 with StandardJavaFileManager

use of org.eclipse.ceylon.javax.tools.StandardJavaFileManager in project ceylon by eclipse.

the class CreateSymbols method createSymbols.

void createSymbols() throws IOException {
    Set<String> legacy = getLegacyPackages();
    Set<String> legacyProprietary = getLegacyPackages();
    Set<String> documented = new HashSet<String>();
    Set<PackageSymbol> packages = ((JavacProcessingEnvironment) processingEnv).getSpecifiedPackages();
    Map<String, String> pOptions = processingEnv.getOptions();
    String jarName = pOptions.get("org.eclipse.ceylon.langtools.tools.javac.sym.Jar");
    if (jarName == null)
        throw new RuntimeException("Must use -Aorg.eclipse.ceylon.langtools.tools.javac.sym.Jar=LOCATION_OF_JAR");
    String destName = pOptions.get("org.eclipse.ceylon.langtools.tools.javac.sym.Dest");
    if (destName == null)
        throw new RuntimeException("Must use -Aorg.eclipse.ceylon.langtools.tools.javac.sym.Dest=LOCATION_OF_JAR");
    String profileSpec = pOptions.get("org.eclipse.ceylon.langtools.tools.javac.sym.Profiles");
    if (profileSpec == null)
        throw new RuntimeException("Must use -Aorg.eclipse.ceylon.langtools.tools.javac.sym.Profiles=PROFILES_SPEC");
    Profiles profiles = Profiles.read(new File(profileSpec));
    for (PackageSymbol psym : packages) {
        String name = psym.getQualifiedName().toString();
        legacyProprietary.remove(name);
        documented.add(name);
    }
    JavaCompiler tool = ToolProvider.getSystemJavaCompiler();
    StandardJavaFileManager fm = tool.getStandardFileManager(null, null, null);
    Location jarLocation = StandardLocation.locationFor(jarName);
    File jarFile = new File(jarName);
    fm.setLocation(jarLocation, List.of(jarFile));
    fm.setLocation(StandardLocation.CLASS_PATH, List.<File>nil());
    fm.setLocation(StandardLocation.SOURCE_PATH, List.<File>nil());
    {
        ArrayList<File> bootClassPath = new ArrayList<File>();
        bootClassPath.add(jarFile);
        for (File path : fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH)) {
            if (!new File(path.getName()).equals(new File("rt.jar")))
                bootClassPath.add(path);
        }
        System.err.println("Using boot class path = " + bootClassPath);
        fm.setLocation(StandardLocation.PLATFORM_CLASS_PATH, bootClassPath);
    }
    // System.out.println(fm.getLocation(StandardLocation.PLATFORM_CLASS_PATH));
    File destDir = new File(destName);
    if (!destDir.exists())
        if (!destDir.mkdirs())
            throw new RuntimeException("Could not create " + destDir);
    fm.setLocation(StandardLocation.CLASS_OUTPUT, List.of(destDir));
    Set<String> hiddenPackages = new HashSet<String>();
    Set<String> crisp = new HashSet<String>();
    List<String> options = List.of("-XDdev");
    // options = options.prepend("-doe");
    // options = options.prepend("-verbose");
    JavacTaskImpl task = (JavacTaskImpl) tool.getTask(null, fm, null, options, null, null);
    org.eclipse.ceylon.langtools.tools.javac.main.JavaCompiler compiler = org.eclipse.ceylon.langtools.tools.javac.main.JavaCompiler.instance(task.getContext());
    ClassWriter writer = ClassWriter.instance(task.getContext());
    Symtab syms = Symtab.instance(task.getContext());
    Names names = Names.instance(task.getContext());
    Attribute.Compound proprietaryAnno = new Attribute.Compound(syms.proprietaryType, List.<Pair<Symbol.MethodSymbol, Attribute>>nil());
    Attribute.Compound[] profileAnnos = new Attribute.Compound[profiles.getProfileCount() + 1];
    Symbol.MethodSymbol profileValue = (MethodSymbol) syms.profileType.tsym.members().lookup(names.value).sym;
    for (int i = 1; i < profileAnnos.length; i++) {
        profileAnnos[i] = new Attribute.Compound(syms.profileType, List.<Pair<Symbol.MethodSymbol, Attribute>>of(new Pair<Symbol.MethodSymbol, Attribute>(profileValue, new Attribute.Constant(syms.intType, i))));
    }
    Type.moreInfo = true;
    Types types = Types.instance(task.getContext());
    Pool pool = new Pool(types);
    for (JavaFileObject file : fm.list(jarLocation, "", EnumSet.of(JavaFileObject.Kind.CLASS), true)) {
        String className = fm.inferBinaryName(jarLocation, file);
        int index = className.lastIndexOf('.');
        String pckName = index == -1 ? "" : className.substring(0, index);
        boolean addLegacyAnnotation = false;
        if (documented.contains(pckName)) {
            if (!legacy.contains(pckName))
                crisp.add(pckName);
        // System.out.println("Documented: " + className);
        } else if (legacyProprietary.contains(pckName)) {
            addLegacyAnnotation = true;
        // System.out.println("Legacy proprietary: " + className);
        } else {
            // System.out.println("Hidden " + className);
            hiddenPackages.add(pckName);
            continue;
        }
        TypeSymbol sym = (TypeSymbol) compiler.resolveIdent(className);
        if (sym.kind != Kinds.TYP) {
            if (className.indexOf('$') < 0) {
                System.err.println("Ignoring (other) " + className + " : " + sym);
                System.err.println("   " + sym.getClass().getSimpleName() + " " + sym.type);
            }
            continue;
        }
        sym.complete();
        if (sym.getEnclosingElement().getKind() != ElementKind.PACKAGE) {
            System.err.println("Ignoring (bad) " + sym.getQualifiedName());
            continue;
        }
        ClassSymbol cs = (ClassSymbol) sym;
        if (addLegacyAnnotation) {
            cs.prependAttributes(List.of(proprietaryAnno));
        }
        int p = profiles.getProfile(cs.fullname.toString().replace(".", "/"));
        if (0 < p && p < profileAnnos.length)
            cs.prependAttributes(List.of(profileAnnos[p]));
        writeClass(pool, cs, writer);
    }
    if (false) {
        for (String pckName : crisp) System.out.println("Crisp: " + pckName);
        for (String pckName : hiddenPackages) System.out.println("Hidden: " + pckName);
        for (String pckName : legacyProprietary) System.out.println("Legacy proprietary: " + pckName);
        for (String pckName : documented) System.out.println("Documented: " + pckName);
    }
}

Example 4 with StandardJavaFileManager

use of org.eclipse.ceylon.javax.tools.StandardJavaFileManager in project ceylon by eclipse.

the class CeylonDocToolTests method compileSdkJavaFiles.

/**
 * This is disgusting, but the current CeylonDoc doesn't handle source files, so we need to compile them first,
 * and we do it using javac to avoid compiling the whole SDK for one java file.
 */
private void compileSdkJavaFiles() throws FileNotFoundException, IOException {
    // put it all in a special folder
    File dir = new File("build", "CeylonDocToolTest/" + name.getMethodName());
    if (dir.exists()) {
        FileUtil.delete(dir);
    }
    dir.mkdirs();
    // download a required jar
    RepositoryManager repoManager = CeylonUtils.repoManager().systemRepo("../dist/dist/repo").buildManager();
    File jbossModulesModule = repoManager.getArtifact(new ArtifactContext(null, "org.jboss.modules", Versions.DEPENDENCY_JBOSS_MODULES_VERSION, ".jar"));
    File runtimeModule = repoManager.getArtifact(new ArtifactContext(null, "ceylon.runtime", Versions.CEYLON_VERSION_NUMBER, ".jar"));
    File modelModule = repoManager.getArtifact(new ArtifactContext(null, "org.eclipse.ceylon.model", Versions.CEYLON_VERSION_NUMBER, ".jar"));
    File undertowCoreModule = repoManager.getArtifact(new ArtifactContext(null, "io.undertow.core", "1.3.5.Final", ".jar"));
    File languageModule = repoManager.getArtifact(new ArtifactContext(null, AbstractModelLoader.CEYLON_LANGUAGE, TypeChecker.LANGUAGE_MODULE_VERSION, ".car"));
    // fire up the java compiler
    JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
    assertNotNull("Missing Java compiler, this test is probably being run with a JRE instead of a JDK!", compiler);
    List<String> options = Arrays.asList("-sourcepath", "../../ceylon-sdk/source", "-d", dir.getAbsolutePath(), "-classpath", undertowCoreModule.getAbsolutePath() + File.pathSeparator + jbossModulesModule.getAbsolutePath() + File.pathSeparator + runtimeModule.getAbsolutePath() + File.pathSeparator + modelModule.getAbsolutePath() + File.pathSeparator + languageModule.getAbsolutePath());
    StandardJavaFileManager fileManager = compiler.getStandardFileManager(null, null, null);
    String[] fileNames = new String[] { "ceylon/interop/java/internal/javaBooleanArray_.java", "ceylon/interop/java/internal/javaByteArray_.java", "ceylon/interop/java/internal/javaCharArray_.java", "ceylon/interop/java/internal/javaDoubleArray_.java", "ceylon/interop/java/internal/javaFloatArray_.java", "ceylon/interop/java/internal/javaIntArray_.java", "ceylon/interop/java/internal/javaLongArray_.java", "ceylon/interop/java/internal/javaObjectArray_.java", "ceylon/interop/java/internal/javaShortArray_.java", "ceylon/interop/java/internal/javaStringArray_.java", "ceylon/interop/java/internal/synchronize_.java" };
    List<String> qualifiedNames = new ArrayList<String>(fileNames.length);
    for (String name : fileNames) {
        qualifiedNames.add("../../ceylon-sdk/source/" + name);
    }
    Iterable<? extends JavaFileObject> fileObjects = fileManager.getJavaFileObjectsFromStrings(qualifiedNames);
    CompilationTask task = compiler.getTask(null, null, null, options, null, fileObjects);
    Boolean ret = task.call();
    Assert.assertEquals("Compilation failed", Boolean.TRUE, ret);
    // now we need to zip it up
    makeCarFromClassFiles(dir, fileNames, "ceylon.test", Versions.CEYLON_VERSION_NUMBER);
    makeCarFromClassFiles(dir, fileNames, "ceylon.http.server", Versions.CEYLON_VERSION_NUMBER);
    makeCarFromClassFiles(dir, fileNames, "ceylon.interop.java", Versions.CEYLON_VERSION_NUMBER);
    makeCarFromClassFiles(dir, fileNames, "ceylon.transaction", Versions.CEYLON_VERSION_NUMBER);
}

Example 5 with StandardJavaFileManager

use of org.eclipse.ceylon.javax.tools.StandardJavaFileManager in project ceylon by eclipse.

the class CompilerTests method compileJavaModule.

protected void compileJavaModule(File jarOutputFolder, File classesOutputFolder, String moduleName, String moduleVersion, File sourceFolder, File[] extraClassPath, String... sourceFileNames) throws IOException {
    JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
    assertNotNull("Missing Java compiler, this test is probably being run with a JRE instead of a JDK!", javaCompiler);
    StandardJavaFileManager fileManager = javaCompiler.getStandardFileManager(null, null, null);
    Set<String> sourceDirectories = new HashSet<String>();
    File[] javaSourceFiles = new File[sourceFileNames.length];
    for (int i = 0; i < javaSourceFiles.length; i++) {
        javaSourceFiles[i] = new File(sourceFolder, sourceFileNames[i]);
        String sfn = sourceFileNames[i].replace(File.separatorChar, '/');
        int p = sfn.lastIndexOf('/');
        String sourceDir = sfn.substring(0, p);
        sourceDirectories.add(sourceDir);
    }
    Iterable<? extends JavaFileObject> compilationUnits = fileManager.getJavaFileObjects(javaSourceFiles);
    StringBuilder cp = new StringBuilder();
    for (int i = 0; i < extraClassPath.length; i++) {
        if (i > 0)
            cp.append(File.pathSeparator);
        cp.append(extraClassPath[i]);
    }
    CompilationTask task = javaCompiler.getTask(null, null, null, Arrays.asList("-d", classesOutputFolder.getPath(), "-cp", cp.toString(), "-sourcepath", sourceFolder.getPath()), null, compilationUnits);
    assertEquals(Boolean.TRUE, task.call());
    File jarFolder = new File(jarOutputFolder, moduleName.replace('.', File.separatorChar) + File.separatorChar + moduleVersion);
    jarFolder.mkdirs();
    File jarFile = new File(jarFolder, moduleName + "-" + moduleVersion + ".jar");
    // now jar it up
    JarOutputStream outputStream = new JarOutputStream(new FileOutputStream(jarFile));
    for (String sourceFileName : sourceFileNames) {
        String classFileName = sourceFileName.substring(0, sourceFileName.length() - 5) + ".class";
        ZipEntry entry = new ZipEntry(classFileName);
        outputStream.putNextEntry(entry);
        File classFile = new File(classesOutputFolder, classFileName);
        FileInputStream inputStream = new FileInputStream(classFile);
        Util.copy(inputStream, outputStream);
        inputStream.close();
        outputStream.flush();
    }
    outputStream.close();
    for (String sourceDir : sourceDirectories) {
        File module = null;
        String sourceName = "module.properties";
        File properties = new File(sourceFolder, sourceDir + File.separator + sourceName);
        if (properties.exists()) {
            module = properties;
        } else {
            sourceName = "module.xml";
            properties = new File(sourceFolder, sourceDir + File.separator + sourceName);
            if (properties.exists()) {
                module = properties;
            }
        }
        if (module != null) {
            File moduleFile = new File(sourceFolder, sourceDir + File.separator + sourceName);
            FileInputStream inputStream = new FileInputStream(moduleFile);
            FileOutputStream moduleOutputStream = new FileOutputStream(new File(jarFolder, sourceName));
            Util.copy(inputStream, moduleOutputStream);
            inputStream.close();
            moduleOutputStream.flush();
            moduleOutputStream.close();
        }
    }
}