Examples with PhasedUnit com.redhat.ceylon.compiler.typechecker.context.PhasedUnit used on opensource projects

Example 11 with PhasedUnit

use of com.redhat.ceylon.compiler.typechecker.context.PhasedUnit in project ceylon-compiler by ceylon.

the class ClassOrPackageDoc method writeParameterAssertions.

private void writeParameterAssertions(Declaration decl, Map<Tree.Assertion, List<Tree.Condition>> parameterAssertions) throws IOException {
    if (parameterAssertions == null || parameterAssertions.isEmpty()) {
        return;
    }
    PhasedUnit pu = tool.getUnit(decl);
    open("div class='assertions' title='Parameter assertions'");
    open("ul");
    for (Tree.Assertion assertion : parameterAssertions.keySet()) {
        List<Annotation> annotations = new ArrayList<Annotation>();
        buildAnnotations(assertion.getAnnotationList(), annotations);
        String doc = Util.getRawDoc(decl.getUnit(), annotations);
        if (!Util.isEmpty(doc)) {
            open("li");
            write("<i class='icon-assertion'></i>");
            write(Util.wikiToHTML(doc, linkRenderer()));
            close("li");
        } else {
            for (Tree.Condition c : parameterAssertions.get(assertion)) {
                String sourceCode = getSourceCode(pu, c);
                open("li");
                write("<i class='icon-assertion'></i>");
                around("code", sourceCode);
                close("li");
            }
        }
    }
    close("ul");
    close("div");
}

Example 12 with PhasedUnit

use of com.redhat.ceylon.compiler.typechecker.context.PhasedUnit in project ceylon-compiler by ceylon.

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 13 with PhasedUnit

use of com.redhat.ceylon.compiler.typechecker.context.PhasedUnit in project ceylon-compiler by ceylon.

the class ModelLoaderTests method compareNativeRuntimeWithJavaRuntime.

@Test
public void compareNativeRuntimeWithJavaRuntime() {
    // parse the ceylon sources from the language module and 
    // build a map of all the native declarations
    final Map<String, Declaration> nativeFromSource = new HashMap<String, Declaration>();
    ClosableVirtualFile latestZippedLanguageSourceFile = getLatestZippedLanguageSourceFile();
    try {
        TypeCheckerBuilder typeCheckerBuilder = new TypeCheckerBuilder().verbose(false).addSrcDirectory(latestZippedLanguageSourceFile);
        TypeChecker typeChecker = typeCheckerBuilder.getTypeChecker();
        typeChecker.process();
        for (PhasedUnit pu : typeChecker.getPhasedUnits().getPhasedUnits()) {
            for (Declaration d : pu.getDeclarations()) {
                if (d.isNativeHeader() && d.isToplevel()) {
                    String qualifiedNameString = d.getQualifiedNameString();
                    String key = d.getDeclarationKind() + ":" + qualifiedNameString;
                    Declaration prev = nativeFromSource.put(key, d);
                    if (prev != null) {
                        Assert.fail("Two declarations with the same key " + key + ": " + d + " and: " + prev);
                    }
                }
            }
        }
    } finally {
        latestZippedLanguageSourceFile.close();
    }
    System.out.println(nativeFromSource);
    // now compile something (it doesn't matter what, we just need 
    // to get our hands on from-binary models for the language module) 
    RunnableTest tester = new RunnableTest() {

        @Override
        public void test(ModelLoader loader) {
            OtherModelCompare comparer = new OtherModelCompare();
            Module binaryLangMod = loader.getLoadedModule(AbstractModelLoader.CEYLON_LANGUAGE, Versions.CEYLON_VERSION_NUMBER);
            for (Map.Entry<String, Declaration> entry : nativeFromSource.entrySet()) {
                System.out.println(entry.getKey());
                Declaration source = entry.getValue();
                ModelLoader.DeclarationType dt = null;
                switch(source.getDeclarationKind()) {
                    case TYPE:
                    case TYPE_PARAMETER:
                        dt = DeclarationType.TYPE;
                        break;
                    case MEMBER:
                    case SETTER:
                        dt = DeclarationType.VALUE;
                        break;
                }
                // Ensure the package is loaded
                binaryLangMod.getDirectPackage(source.getQualifiedNameString().replaceAll("::.*", ""));
                Declaration binary = loader.getDeclaration(binaryLangMod, source.getQualifiedNameString().replace("::", "."), dt);
                comparer.compareDeclarations(source.getQualifiedNameString(), source, binary);
            }
        }
    };
    verifyCompilerClassLoading("Any.ceylon", tester, defaultOptions);
    verifyRuntimeClassLoading(tester);
}

Example 14 with PhasedUnit

use of com.redhat.ceylon.compiler.typechecker.context.PhasedUnit in project ceylon-compiler by ceylon.

the class LanguageCompiler method loadCompiledModules.

private List<JCCompilationUnit> loadCompiledModules(List<JCCompilationUnit> trees, LinkedList<JCCompilationUnit> moduleTrees) {
    compilerDelegate.visitModules(phasedUnits);
    Modules modules = ceylonContext.getModules();
    // now make sure the phase units have their modules and packages set correctly
    for (PhasedUnit pu : phasedUnits.getPhasedUnits()) {
        Package pkg = pu.getPackage();
        loadModuleFromSource(pkg, modules, moduleTrees, trees);
    }
    // also make sure we have packages and modules set up for every Java file we compile
    for (JCCompilationUnit cu : trees) {
        // skip Ceylon CUs
        if (cu instanceof CeylonCompilationUnit)
            continue;
        String packageName = "";
        if (cu.pid != null)
            packageName = TreeInfo.fullName(cu.pid).toString();
        /*
             * Stef: see javadoc for findOrCreateModulelessPackage() for why this is here.
             */
        Package pkg = modelLoader.findOrCreateModulelessPackage(packageName);
        loadModuleFromSource(pkg, modules, moduleTrees, trees);
    }
    for (PhasedUnit phasedUnit : phasedUnits.getPhasedUnits()) {
        for (Tree.ModuleDescriptor modDescr : phasedUnit.getCompilationUnit().getModuleDescriptors()) {
            String name = phasedUnit.getPackage().getNameAsString();
            CeylonPhasedUnit cpu = (CeylonPhasedUnit) phasedUnit;
            CeylonFileObject cfo = (CeylonFileObject) cpu.getFileObject();
            moduleNamesToFileObjects.put(name, cfo);
        }
    }
    for (JCCompilationUnit moduleTree : moduleTrees) {
        trees = trees.append(moduleTree);
    }
    return trees;
}

Example 15 with PhasedUnit

use of com.redhat.ceylon.compiler.typechecker.context.PhasedUnit in project ceylon-compiler by ceylon.

the class CeyloncCompilerDelegate method typeCheck.

@Override
public void typeCheck(java.util.List<PhasedUnit> listOfUnits) {
    StatusPrinter sp = getStatusPrinter();
    int size = listOfUnits.size();
    int i = 1;
    for (PhasedUnit pu : listOfUnits) {
        if (sp != null)
            progress(sp, 1, i++, size, pu);
        pu.validateTree();
        pu.scanDeclarations();
    }
    i = 1;
    for (PhasedUnit pu : listOfUnits) {
        if (sp != null)
            progress(sp, 2, i++, size, pu);
        pu.scanTypeDeclarations();
    }
    i = 1;
    for (PhasedUnit pu : listOfUnits) {
        if (sp != null)
            progress(sp, 3, i++, size, pu);
        pu.validateRefinement();
    }
    i = 1;
    for (PhasedUnit pu : listOfUnits) {
        if (sp != null)
            progress(sp, 4, i++, size, pu);
        pu.analyseTypes();
    }
    i = 1;
    for (PhasedUnit pu : listOfUnits) {
        if (sp != null)
            progress(sp, 5, i++, size, pu);
        pu.analyseFlow();
    }
    i = 1;
    for (PhasedUnit pu : listOfUnits) {
        if (sp != null)
            progress(sp, 6, i++, size, pu);
        pu.analyseUsage();
    }
    i = 1;
    UnknownTypeCollector utc = new UnknownTypeCollector();
    for (PhasedUnit pu : listOfUnits) {
        if (sp != null)
            progress(sp, 7, i++, size, pu);
        pu.getCompilationUnit().visit(utc);
    }
}