Examples with RuntimeModelLoader org.eclipse.ceylon.compiler.java.runtime.model.RuntimeModelLoader used on opensource projects

Example 1 with RuntimeModelLoader

use of org.eclipse.ceylon.compiler.java.runtime.model.RuntimeModelLoader in project ceylon by eclipse.

the class ModuleImpl method resourceByPath.

@Override
@TypeInfo("ceylon.language::Resource")
public Resource resourceByPath(@Name("path") String path) {
    String fullPath = path;
    if (!fullPath.startsWith("/")) {
        String modPath = ("default".equals(getName())) ? "" : getName().replace('.', '/') + "/";
        fullPath = modPath + path;
    } else {
        fullPath = fullPath.substring(1);
    }
    fullPath = JVMModuleUtil.quoteJavaKeywordsInFilename(fullPath);
    // First lets ask the module manager for the contents of the resource
    RuntimeModuleManager moduleManager = Metamodel.getModuleManager();
    if (moduleManager != null) {
        RuntimeModelLoader modelLoader = moduleManager.getModelLoader();
        if (modelLoader != null) {
            byte[] contents = modelLoader.getContents(declaration, fullPath);
            if (contents != null) {
                URI uri = modelLoader.getContentUri(declaration, fullPath);
                return new ByteArrayResource(contents, uri);
            }
        }
    }
    // Second let's see if we can find the on-disk location of the module
    String moduleUnitFullPath = declaration.getUnit().getFullPath();
    if (moduleUnitFullPath != null) {
        final File car = new File(moduleUnitFullPath);
        // Then let's look inside the car
        try (ZipFile zip = new ZipFile(car)) {
            ZipEntry e = zip.getEntry(fullPath);
            if (e != null && !e.isDirectory()) {
                return new ZipResource(car, fullPath);
            }
        } catch (IOException ex) {
            throw new ceylon.language.Exception(new ceylon.language.String("Searching for resource " + path), ex);
        }
        // And finally as a fall-back let's look in the module's resource dir...
        final File target = new File(new File(car.getParentFile(), "module-resources"), fullPath);
        if (target.exists() && target.isFile() && target.canRead()) {
            return new FileResource(target);
        }
    }
    // One last shot: we might be in a fat jar
    try (InputStream stream = getClass().getClassLoader().getResourceAsStream(fullPath)) {
        if (stream != null) {
            byte[] buf = new byte[16384];
            ByteArrayOutputStream bout = new ByteArrayOutputStream();
            int bytesRead = stream.read(buf);
            while (bytesRead > 0) {
                bout.write(buf, 0, bytesRead);
                bytesRead = stream.read(buf);
            }
            return new ByteArrayResource(bout.toByteArray(), new URI("classpath:" + fullPath));
        }
    } catch (IOException | URISyntaxException ex) {
        throw new ceylon.language.Exception(new ceylon.language.String("Searching for resource " + path), ex);
    }
    return null;
}

Example 2 with RuntimeModelLoader

use of org.eclipse.ceylon.compiler.java.runtime.model.RuntimeModelLoader in project ceylon by eclipse.

the class ModelLoaderTests method verifyCompilerClassLoading.

protected void verifyCompilerClassLoading(String ceylon, final ModelComparison modelCompare) {
    // now compile the ceylon decl file
    CeyloncTaskImpl task = getCompilerTask(ceylon);
    // get the context to grab the phased units
    Context context = task.getContext();
    if (simpleAnnotationModels) {
        CeylonEnter.instance(context);
        ExpressionTransformer.getInstance(context).simpleAnnotationModels = true;
        CeylonTransformer.getInstance(context).simpleAnnotationModels = true;
        StatementTransformer.getInstance(context).simpleAnnotationModels = true;
        ClassTransformer.getInstance(context).simpleAnnotationModels = true;
    }
    Boolean success = task.call();
    Assert.assertTrue(success);
    PhasedUnits phasedUnits = LanguageCompiler.getPhasedUnitsInstance(context);
    // find out what was in that file
    Assert.assertEquals(2, phasedUnits.getPhasedUnits().size());
    PhasedUnit one = phasedUnits.getPhasedUnits().get(0);
    PhasedUnit two = phasedUnits.getPhasedUnits().get(1);
    PhasedUnit phasedUnit = one.getUnitFile().getName().endsWith("module.ceylon") ? two : one;
    final Map<String, Declaration> decls = new HashMap<String, Declaration>();
    for (Declaration decl : phasedUnit.getUnit().getDeclarations()) {
        if (decl.isToplevel()) {
            decls.put(getQualifiedPrefixedName(decl), decl);
        }
    }
    // now compile the ceylon usage file
    // remove the extension, make lowercase and add "test"
    String testfile = ceylon.substring(0, ceylon.length() - 7).toLowerCase() + "test.ceylon";
    JavacTaskImpl task2 = getCompilerTask(testfile);
    // get the context to grab the declarations
    final Context context2 = task2.getContext();
    // declarations from the jar anymore because we've overridden the jar and the javac jar index is corrupted
    class Listener implements TaskListener {

        @Override
        public void started(TaskEvent e) {
        }

        @Override
        public void finished(TaskEvent e) {
            if (e.getKind() == Kind.ENTER) {
                AbstractModelLoader modelLoader = CeylonModelLoader.instance(context2);
                Modules modules = LanguageCompiler.getCeylonContextInstance(context2).getModules();
                // now see if we can find our declarations
                compareDeclarations(modelCompare, decls, modelLoader, modules);
            }
        }
    }
    Listener listener = new Listener();
    task2.setTaskListener(listener);
    success = task2.call();
    Assert.assertTrue("Compilation failed", success);
    // now check with the runtime model loader too
    String module = moduleForJavaModelLoading();
    String version = "1";
    ModuleWithArtifact moduleWithArtifact = new ModuleWithArtifact(module, version);
    synchronized (RUN_LOCK) {
        // this initialises the metamodel, even if we don't use the resulting ClassLoader
        URLClassLoader classLoader;
        try {
            classLoader = getClassLoader("runtime model loader tests", moduleWithArtifact);
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        }
        try {
            RuntimeModuleManager moduleManager = Metamodel.getModuleManager();
            RuntimeModelLoader modelLoader = moduleManager.getModelLoader();
            Modules modules = moduleManager.getModules();
            // now see if we can find our declarations
            compareDeclarations(modelCompare, decls, modelLoader, modules);
        } finally {
            try {
                classLoader.close();
            } catch (IOException e) {
                // ignore
                e.printStackTrace();
            }
        }
    }
}

Example 3 with RuntimeModelLoader

use of org.eclipse.ceylon.compiler.java.runtime.model.RuntimeModelLoader in project ceylon by eclipse.

the class ModelLoaderTests method verifyRuntimeClassLoading.

protected void verifyRuntimeClassLoading(RunnableTest test) {
    RepositoryManager repoManager = CeylonUtils.repoManager().systemRepo(getSysRepPath()).buildManager();
    VFS vfs = new VFS();
    org.eclipse.ceylon.compiler.typechecker.context.Context context = new org.eclipse.ceylon.compiler.typechecker.context.Context(repoManager, vfs);
    RuntimeModuleManager moduleManager = new RuntimeModuleManager(null);
    context.setModules(new Modules());
    moduleManager.initCoreModules(new Modules());
    moduleManager.loadModule(AbstractModelLoader.CEYLON_LANGUAGE, Versions.CEYLON_VERSION_NUMBER, repoManager.getArtifactResult(null, "ceylon.language", Versions.CEYLON_VERSION_NUMBER), getClass().getClassLoader());
    RuntimeModelLoader modelLoader = moduleManager.getModelLoader();
    modelLoader.setupWithNoStandardModules();
    modelLoader.loadStandardModules();
    test.test(modelLoader);
}

Example 4 with RuntimeModelLoader

use of org.eclipse.ceylon.compiler.java.runtime.model.RuntimeModelLoader in project ceylon by eclipse.

the class RuntimeModuleManager method loadModule.

public boolean loadModule(String name, String version, ArtifactResult artifact, ClassLoader classLoader, boolean staticMetamodel) {
    RuntimeModelLoader modelLoader = getModelLoader();
    synchronized (modelLoader.getLock()) {
        manualMetamodelSetup = true;
        Module module = getOrCreateModule(splitModuleName(name), version);
        // ones setting the module's Unit
        if (module.isDefaultModule() ? module.getUnit() != null : module.isAvailable())
            return false;
        modelLoader.addModuleToClassPath(module, artifact);
        modelLoader.addModuleClassLoader(module, classLoader);
        module.setAvailable(true);
        Unit u = new Unit();
        u.setFilename(artifact.name());
        if (artifact.artifact() != null) {
            u.setFullPath(artifact.artifact().getAbsolutePath());
        }
        module.setUnit(u);
        if (module.isLanguageModule())
            modelLoader.loadPackageDescriptors();
        if (!module.isDefaultModule()) {
            // FIXME: dependencies of Ceylon modules?
            if (!modelLoader.loadCompiledModule(module, !staticMetamodel)) {
                // we didn't find module.class so it must be a java module if it's not the default module
                ((LazyModule) module).setJava(true);
                module.setNativeBackends(Backend.Java.asSet());
                // Java modules must have their dependencies set by the artifact result, as there is no module info in the jar
                loadModuleImportsFromArtifact(module, artifact);
            } else if (staticMetamodel) {
                // for a static metamodel we get the dependencies from the artifact too
                loadModuleImportsFromArtifact(module, artifact);
            }
        }
        return true;
    }
}