// overridden by test subclass
protected String[] getCeylonProjectClasspath(IJavaProject javaProject) throws JavaModelException {
final List<String> classpathList = new ArrayList<String>();
for (CeylonClasspathContainer container : getCeylonClasspathContainers(javaProject)) {
boolean changed = container.resolveClasspath(new NullProgressMonitor(), false);
if (changed) {
container.refreshClasspathContainer(new NullProgressMonitor(), javaProject);
}
}
// add the car files of the output directory
IProject project = javaProject.getProject();
Context context = getProjectTypeChecker(project).getContext();
IPath modulesFolder = getCeylonModulesOutputFolder(project).getLocation();
classpathList.add(modulesFolder.append("default").append("default.car").toOSString());
RepositoryManager provider = context.getRepositoryManager();
Set<Module> modulesToAdd = context.getModules().getListOfModules();
// modulesToAdd.add(projectModules.getLanguageModule());
for (Module module : modulesToAdd) {
String name = module.getNameAsString();
if (name.equals(Module.DEFAULT_MODULE_NAME)
|| JDKUtils.isJDKModule(name)
|| JDKUtils.isOracleJDKModule(name)
|| !isProjectModule(javaProject, module)) {
continue;
}
IPath modulePath = getModuleArchive(provider, module);
if (modulePath != null) {
if (modulePath.toFile().exists()) {
// if (project.getLocation().isPrefixOf(modulePath)) {
// if (!classpathList.contains(modulePath.toOSString())) {
classpathList.add(modulePath.toOSString());
// }
// }
} else {
System.err.println(
"ignoring nonexistent module artifact for launch classpath: " + modulePath);
}
} else {
System.err.println(
"no module archive found for launch classpath: "
+ module.getNameAsString()
+ "/"
+ module.getVersion());
}
}
return classpathList.toArray(new String[classpathList.size()]);
}
/**
* Prints a list of module name, version, path to the given file, to be used by the runtime
* launcher, because passing it as an argument/environment would easily exceed the OS size limits.
*/
private void writeModuleInfoFile(File tmpFile, ILaunchConfiguration configuration)
throws IOException, CoreException {
FileWriter writer = new FileWriter(tmpFile);
IJavaProject javaProject = getJavaProject(configuration);
IProject project = javaProject.getProject();
Context context = getProjectTypeChecker(project).getContext();
RepositoryManager provider = context.getRepositoryManager();
Set<Module> modulesToAdd = context.getModules().getListOfModules();
boolean seenDefault = false;
for (Module module : modulesToAdd) {
String name = module.getNameAsString();
if (JDKUtils.isJDKModule(name) || JDKUtils.isOracleJDKModule(name)) {
continue;
}
if (module.isDefault()) seenDefault = true;
IPath modulePath = getModuleArchive(provider, module);
if (modulePath != null && modulePath.toFile().exists()) {
String path = modulePath.toOSString();
System.err.println(
"Adding module: " + module.getNameAsString() + "/" + module.getVersion() + ": " + path);
// print module name + NL (+ version + NL)? + path + NL
writer.append(module.getNameAsString());
writer.append(System.lineSeparator());
if (!module.isDefault()) {
writer.append(module.getVersion());
writer.append(System.lineSeparator());
}
writer.append(path);
writer.append(System.lineSeparator());
}
}
// for some reason the default module can be missing from the list of modules
if (!seenDefault) {
IPath modulesFolder = getCeylonModulesOutputFolder(project).getLocation();
IPath defaultCar = modulesFolder.append("default").append("default.car");
if (defaultCar.toFile().exists()) {
String path = defaultCar.toOSString();
Module module = context.getModules().getDefaultModule();
System.err.println("Adding default module: " + module.getNameAsString() + ": " + path);
// print module name + NL + path + NL
writer.append(module.getNameAsString());
writer.append(System.lineSeparator());
writer.append(path);
writer.append(System.lineSeparator());
}
}
writer.flush();
writer.close();
}
public LanguageCompiler(Context context) {
super(context);
ceylonContext = getCeylonContextInstance(context);
vfs = ceylonContext.getVfs();
compilerDelegate = getCompilerDelegate(context);
phasedUnits = getPhasedUnitsInstance(context);
try {
gen = CeylonTransformer.getInstance(context);
} catch (Exception e) {
throw new RuntimeException(e);
}
modelLoader = CeylonModelLoader.instance(context);
ceylonEnter = CeylonEnter.instance(context);
options = Options.instance(context);
isBootstrap = options.get(Option.BOOTSTRAPCEYLON) != null;
timer = Timer.instance(context);
sourceLanguage = SourceLanguage.instance(context);
boolean isProgressPrinted =
options.get(Option.CEYLONPROGRESS) != null && StatusPrinter.canPrint();
if (isProgressPrinted) {
sp = getStatusPrinterInstance(context);
if (taskListener == null) {
taskListener.add(new StatusPrinterTaskListener(sp));
}
}
}
private void 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);
}
}
}
public LanguageCompiler(Context context) {
super(context);
ceylonContext = getCeylonContextInstance(context);
vfs = ceylonContext.getVfs();
phasedUnits = getPhasedUnitsInstance(context);
try {
gen = CeylonTransformer.getInstance(context);
} catch (Exception e) {
throw new RuntimeException(e);
}
modelLoader = CeylonModelLoader.instance(context);
ceylonEnter = CeylonEnter.instance(context);
options = Options.instance(context);
}
public LanguageCompiler(Context context) {
super(context);
ceylonContext = getCeylonContextInstance(context);
vfs = ceylonContext.getVfs();
compilerDelegate = getCompilerDelegate(context);
phasedUnits = getPhasedUnitsInstance(context);
try {
gen = CeylonTransformer.getInstance(context);
} catch (Exception e) {
throw new RuntimeException(e);
}
modelLoader = CeylonModelLoader.instance(context);
ceylonEnter = CeylonEnter.instance(context);
options = Options.instance(context);
isBootstrap = options.get(OptionName.BOOTSTRAPCEYLON) != null;
timer = Timer.instance(context);
}
private void loadCompiledModules(
List<JCCompilationUnit> trees, LinkedList<JCCompilationUnit> moduleTrees) {
phasedUnits.visitModules();
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);
}
// 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();
Package pkg = modelLoader.findOrCreatePackage(null, packageName);
loadModuleFromSource(pkg, modules, moduleTrees);
}
}
private Module loadModuleFromSource(
String pkgName,
LinkedList<JCCompilationUnit> moduleTrees,
List<JCCompilationUnit> parsedTrees) {
if (pkgName.isEmpty()) return null;
String moduleClassName = pkgName + ".module";
JavaFileObject fileObject;
try {
if (options.get(Option.VERBOSE) != null) {
log.printRawLines(
WriterKind.NOTICE, "[Trying to load source for module " + moduleClassName + "]");
}
fileObject =
fileManager.getJavaFileForInput(
StandardLocation.SOURCE_PATH, moduleClassName, Kind.SOURCE);
if (options.get(Option.VERBOSE) != null) {
log.printRawLines(WriterKind.NOTICE, "[Got file object: " + fileObject + "]");
}
} catch (IOException e) {
e.printStackTrace();
return loadModuleFromSource(getParentPackage(pkgName), moduleTrees, parsedTrees);
}
if (fileObject != null) {
// first make sure we're not already compiling it: this can happen if we have several versions
// of the
// same module already loaded: we will get one which isn't the one we compile, but that's not
// the one
// we really want to compile.
for (JCCompilationUnit parsedTree : parsedTrees) {
if (parsedTree.sourcefile.equals(fileObject)
&& parsedTree instanceof CeylonCompilationUnit) {
// same file! we already parsed it, let's return this one's module
PhasedUnit phasedUnit = ((CeylonCompilationUnit) parsedTree).phasedUnit;
// the module visitor does load the module but does not set the unit's package module
if (phasedUnit.getPackage().getModule() == null) {
// so find the module it created
for (Module mod : ceylonContext.getModules().getListOfModules()) {
// we recognise it with the unit
if (mod.getUnit() == phasedUnit.getUnit()) {
// set the package's module
Package pkg = phasedUnit.getPackage();
pkg.setModule(mod);
mod.getPackages().add(pkg);
modulesLoadedFromSource.add(mod);
break;
}
}
}
// now return it
return phasedUnit.getPackage().getModule();
}
}
JCCompilationUnit javaCompilationUnit = parse(fileObject);
Module module;
if (javaCompilationUnit instanceof CeylonCompilationUnit) {
CeylonCompilationUnit ceylonCompilationUnit = (CeylonCompilationUnit) javaCompilationUnit;
moduleTrees.add(ceylonCompilationUnit);
// parse the module info from there
module = ceylonCompilationUnit.phasedUnit.visitSrcModulePhase();
ceylonCompilationUnit.phasedUnit.visitRemainingModulePhase();
// now set the module
if (module != null) {
ceylonCompilationUnit.phasedUnit.getPackage().setModule(module);
}
} else {
// there was a syntax error in the module descriptor, make a pretend module so that we can
// correctly mark all declarations as part of that module, but we won't generate any code
// for it
ModuleManager moduleManager = phasedUnits.getModuleManager();
module = moduleManager.getOrCreateModule(Arrays.asList(pkgName.split("\\.")), "bogus");
}
// now remember it
if (module != null) {
modulesLoadedFromSource.add(module);
return module;
}
}
return loadModuleFromSource(getParentPackage(pkgName), moduleTrees, parsedTrees);
}
