private void addResources() throws Abort { HashSet<String> written = new HashSet<String>(); try { for (JavaFileObject fo : resourceFileObjects) { CeyloncFileManager dfm = (CeyloncFileManager) fileManager; String jarFileName = JarUtils.toPlatformIndependentPath( dfm.getLocation(CeylonLocation.RESOURCE_PATH), fo.getName()); if (!written.contains(jarFileName)) { dfm.setModule(modelLoader.findModuleForFile(new File(jarFileName))); FileObject outFile = dfm.getFileForOutput(StandardLocation.CLASS_OUTPUT, "", jarFileName, null); OutputStream out = outFile.openOutputStream(); try { InputStream in = new FileInputStream(new File(fo.getName())); try { JarUtils.copy(in, out); } finally { in.close(); } } finally { out.close(); } written.add(jarFileName); } } } catch (IOException ex) { throw new Abort(ex); } }
@Override public List<JCCompilationUnit> parseFiles(Iterable<JavaFileObject> fileObjects) { timer.startTask("parse"); /* * Stef: see javadoc for fixDefaultPackage() for why this is here. */ modelLoader.fixDefaultPackage(); List<JCCompilationUnit> trees = super.parseFiles(fileObjects); timer.startTask("loadCompiledModules"); LinkedList<JCCompilationUnit> moduleTrees = new LinkedList<JCCompilationUnit>(); // now load modules and associate their moduleless packages with the corresponding modules trees = loadCompiledModules(trees, moduleTrees); /* * Stef: see javadoc for cacheModulelessPackages() for why this is here. */ modelLoader.cacheModulelessPackages(); timer.endTask(); return trees; }
protected void setupIfJDKModule(LazyModule module) { // Make sure that the java modules are set up properly. // Bad jdk versions will not be made available and the module validator // will fail to load their artifacts, and the error is properly handled by the lazy module // manager in // attachErrorToDependencyDeclaration() String nameAsString = module.getNameAsString(); String version = module.getVersion(); if (version != null && AbstractModelLoader.isJDKModule(nameAsString)) { if (JDKUtils.jdk.providesVersion(version)) { module.setAvailable(true); module.setJava(true); module.setNativeBackend(Backend.Java.nativeAnnotation); } } }
@Override public void initRound(JavaCompiler prev) { super.initRound(prev); // round compilers don't add module trees, it's already done by the first one addModuleTrees = false; PhasedUnits oldPUs = ((LanguageCompiler) prev).phasedUnits; ModuleManager moduleManager = phasedUnits.getModuleManager(); ModuleSourceMapper moduleSourceMapper = phasedUnits.getModuleSourceMapper(); for (PhasedUnit pu : oldPUs.getPhasedUnits()) { if (pu instanceof CeylonPhasedUnit) { CeylonPhasedUnit cpu = (CeylonPhasedUnit) pu; // FIXME: this is bad in many ways String pkgName; try { pkgName = getPackage(((CeylonPhasedUnit) pu).getFileObject()); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); continue; } // make a Package with no module yet, we will resolve them later /* * Stef: see javadoc for findOrCreateModulelessPackage() for why this is here. */ com.redhat.ceylon.model.typechecker.model.Package p = modelLoader.findOrCreateModulelessPackage(pkgName == null ? "" : pkgName); CeylonPhasedUnit newPu = new CeylonPhasedUnit( pu.getUnitFile(), pu.getSrcDir(), pu.getCompilationUnit(), p, moduleManager, moduleSourceMapper, ceylonContext, cpu.getFileObject(), cpu.getLineMap()); phasedUnits.addPhasedUnit(pu.getUnitFile(), newPu); } else { phasedUnits.addPhasedUnit(pu.getUnitFile(), pu); } } }
private JavaFileObject genCodeUnlessError(Env<AttrContext> env, JCClassDecl cdef) throws IOException { CeylonFileObject sourcefile = (CeylonFileObject) env.toplevel.sourcefile; try { // do not look at the global number of errors but only those for this file if (super.gen.genClass(env, cdef)) { String packageName = cdef.sym.packge().getQualifiedName().toString(); Package pkg = modelLoader.findPackage(packageName); if (pkg == null) throw new RuntimeException("Failed to find package: " + packageName); Module module = pkg.getModule(); if (!module.isDefaultModule()) { String moduleName = module.getNameAsString(); CeylonFileObject moduleFileObject = moduleNamesToFileObjects.get(moduleName); // if there's no module source file object it means the module descriptor had parse errors if (moduleFileObject == null || moduleFileObject.hasError()) { // we do not produce any class files for modules with errors if (options.get(Option.VERBOSE) != null) { log.printRawLines( WriterKind.NOTICE, "[Not writing class " + cdef.sym.className() + " because its module has errors: " + moduleName + "]"); } return null; } } return writer.writeClass(cdef.sym); } } catch (ClassWriter.PoolOverflow ex) { log.error(cdef.pos(), "limit.pool"); } catch (ClassWriter.StringOverflow ex) { log.error(cdef.pos(), "limit.string.overflow", ex.value.substring(0, 20)); } catch (CompletionFailure ex) { chk.completionError(cdef.pos(), ex); } catch (AssertionError e) { throw new RuntimeException("Error generating bytecode for " + sourcefile.getName(), e); } return null; }
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); } } if (addModuleTrees) { for (JCCompilationUnit moduleTree : moduleTrees) { trees = trees.append(moduleTree); } } return trees; }
private JCCompilationUnit ceylonParse(JavaFileObject filename, CharSequence readSource) { if (ceylonEnter.hasRun()) throw new RunTwiceException( "Trying to load new source file after CeylonEnter has been called: " + filename); try { ModuleManager moduleManager = phasedUnits.getModuleManager(); ModuleSourceMapper moduleSourceMapper = phasedUnits.getModuleSourceMapper(); File sourceFile = new File(filename.getName()); // FIXME: temporary solution VirtualFile file = vfs.getFromFile(sourceFile); VirtualFile srcDir = vfs.getFromFile(getSrcDir(sourceFile)); String source = readSource.toString(); char[] chars = source.toCharArray(); LineMap map = Position.makeLineMap(chars, chars.length, false); PhasedUnit phasedUnit = null; PhasedUnit externalPhasedUnit = compilerDelegate.getExternalSourcePhasedUnit(srcDir, file); String suppressWarnings = options.get(Option.CEYLONSUPPRESSWARNINGS); final EnumSet<Warning> suppressedWarnings; if (suppressWarnings != null) { if (suppressWarnings.trim().isEmpty()) { suppressedWarnings = EnumSet.allOf(Warning.class); } else { suppressedWarnings = EnumSet.noneOf(Warning.class); for (String name : suppressWarnings.trim().split(" *, *")) { suppressedWarnings.add(Warning.valueOf(name)); } } } else { suppressedWarnings = EnumSet.noneOf(Warning.class); } if (externalPhasedUnit != null) { phasedUnit = new CeylonPhasedUnit(externalPhasedUnit, filename, map); phasedUnit.setSuppressedWarnings(suppressedWarnings); phasedUnits.addPhasedUnit(externalPhasedUnit.getUnitFile(), phasedUnit); gen.setMap(map); String pkgName = phasedUnit.getPackage().getQualifiedNameString(); if ("".equals(pkgName)) { pkgName = null; } return gen.makeJCCompilationUnitPlaceholder( phasedUnit.getCompilationUnit(), filename, pkgName, phasedUnit); } if (phasedUnit == null) { ANTLRStringStream input = new NewlineFixingStringStream(source); CeylonLexer lexer = new CeylonLexer(input); CommonTokenStream tokens = new CommonTokenStream(lexer); CeylonParser parser = new CeylonParser(tokens); CompilationUnit cu = parser.compilationUnit(); java.util.List<LexError> lexerErrors = lexer.getErrors(); for (LexError le : lexerErrors) { printError(le, le.getMessage(), "ceylon.lexer", map); } java.util.List<ParseError> parserErrors = parser.getErrors(); for (ParseError pe : parserErrors) { printError(pe, pe.getMessage(), "ceylon.parser", map); } // if we continue and it's not a descriptor, we don't care about errors if ((options.get(Option.CEYLONCONTINUE) != null && !ModuleManager.MODULE_FILE.equals(sourceFile.getName()) && !ModuleManager.PACKAGE_FILE.equals(sourceFile.getName())) // otherwise we care about errors || (lexerErrors.size() == 0 && parserErrors.size() == 0)) { // FIXME: this is bad in many ways String pkgName = getPackage(filename); // make a Package with no module yet, we will resolve them later /* * Stef: see javadoc for findOrCreateModulelessPackage() for why this is here. */ com.redhat.ceylon.model.typechecker.model.Package p = modelLoader.findOrCreateModulelessPackage(pkgName == null ? "" : pkgName); phasedUnit = new CeylonPhasedUnit( file, srcDir, cu, p, moduleManager, moduleSourceMapper, ceylonContext, filename, map); phasedUnit.setSuppressedWarnings(suppressedWarnings); phasedUnits.addPhasedUnit(file, phasedUnit); gen.setMap(map); return gen.makeJCCompilationUnitPlaceholder(cu, filename, pkgName, phasedUnit); } } } catch (RuntimeException e) { throw e; } catch (Exception e) { throw new RuntimeException(e); } JCCompilationUnit result = make.TopLevel(List.<JCAnnotation>nil(), null, List.<JCTree>of(make.Erroneous())); result.sourcefile = filename; return result; }