private static Language newLanguageInstance(ModuleHandle handle, MPSModuleOwner moduleOwner) {
LanguageDescriptor descriptor = ((LanguageDescriptor) handle.getDescriptor());
assert descriptor != null;
assert descriptor.getId() != null;
return registerModule(new Language(descriptor, handle.getFile()), moduleOwner);
}
public static void delete(
Language sourceLanguage, GeneratorDescriptor generatorDescriptor, boolean deleteFiles) {
LanguageDescriptor languageDescriptor = sourceLanguage.getModuleDescriptor();
languageDescriptor.getGenerators().remove(generatorDescriptor);
sourceLanguage.setLanguageDescriptor(languageDescriptor, true);
sourceLanguage.save();
}
private Language createLanguage() {
LanguageDescriptor d = new LanguageDescriptor();
String uuid = UUID.randomUUID().toString();
d.setNamespace(uuid);
d.setId(ModuleId.fromString(uuid));
return TestLanguage.newInstance(d, OWNER);
}
public static void updateLanguageClasspath(Language l, String classpath) {
LanguageDescriptor languageDescriptor = l.getModuleDescriptor();
ClassPathEntry cpEntry = new ClassPathEntry();
cpEntry.setPath(classpath);
languageDescriptor
.getStubModelEntries()
.add(jetbrains.mps.project.structure.model.ModelRootUtil.fromClassPathEntry(cpEntry));
l.setLanguageDescriptor(languageDescriptor, false);
}
private SNode convertLanguage(LanguageDescriptor source) {
SNode result =
SConceptOperations.createNewNode("jetbrains.mps.lang.project.structure.Language", null);
result.setId(SNodeId.fromString("~root"));
SModelOperations.addRootNode(myModel, result);
fill(result, source);
SPropertyOperations.set(result, "doNotGenerateAdapters", "" + source.isDoNotGenerateAdapters());
SPropertyOperations.set(result, "genPath", source.getGenPath());
SPropertyOperations.set(result, "languagePath", myFile.getPath());
for (SModelReference ref : source.getAccessoryModels()) {
SLinkOperations.getTargets(result, "accessoryModels", true).add(convert(ref));
}
for (GeneratorDescriptor descriptor : source.getGenerators()) {
SLinkOperations.getTargets(result, "generator", true).add(convert(descriptor));
}
for (ModuleReference ref : source.getExtendedLanguages()) {
SLinkOperations.getTargets(result, "extendedLanguages", true).add(convert(ref));
}
for (Dependency dep : source.getRuntimeModules()) {
SLinkOperations.getTargets(result, "runtimeModules", true).add(convert(dep));
}
for (ModelRoot entry : source.getRuntimeStubModels()) {
SLinkOperations.getTargets(result, "runtimeStubModels", true).add(convert(entry));
}
for (StubSolution sol : source.getStubSolutions()) {
SLinkOperations.getTargets(result, "stubSolutions", true).add(convert(sol));
}
collectModels(result, source);
return result;
}
private static void safeDelete(
final Project project,
Language sourceLanguage,
final Generator generator,
GeneratorDescriptor generatorDescriptor,
boolean deleteFiles) {
List<Generator> dependant = new ArrayList<Generator>();
for (Generator gen :
(List<Generator>) ModuleRepositoryFacade.getInstance().getAllModules(Generator.class)) {
if (gen.getReferencedGenerators().contains(generator)) {
dependant.add(gen);
}
}
if (!dependant.isEmpty()) {
final StringBuilder report = new StringBuilder();
report.append("Can't delete generator ").append(generator.getModuleName()).append(".\n");
report.append("The following generators depend on it:\n\n");
for (Generator gen : dependant) {
report.append(gen.getModuleName()).append("\n");
}
SwingUtilities.invokeLater(
new Runnable() {
@Override
public void run() {
Messages.showErrorDialog(
ProjectHelper.toIdeaProject(project), report.toString(), "Deleting Generator");
}
});
return;
}
LanguageDescriptor languageDescriptor = sourceLanguage.getModuleDescriptor();
languageDescriptor.getGenerators().remove(generator.getModuleDescriptor());
sourceLanguage.setLanguageDescriptor(languageDescriptor, true);
if (deleteFiles) {
LOG.error("DELETE GENERATOR FILES - NOT IMPLEMENTED", new Throwable());
// todo
}
sourceLanguage.save();
}
public static void saveLanguageDescriptor(
IFile file, LanguageDescriptor descriptor, MacroHelper macroHelper) {
if (file.isReadOnly()) {
if (LOG.isEnabledFor(Priority.ERROR)) {
LOG.error("Cant't save " + file.getPath());
}
return;
}
Element languageElement = new Element("language");
languageElement.setAttribute("namespace", descriptor.getNamespace());
String uuid = descriptor.getUUID();
if (uuid != null) {
languageElement.setAttribute("uuid", uuid);
}
if (descriptor.getGenPath() != null) {
languageElement.setAttribute(
"generatorOutputPath", macroHelper.shrinkPath(descriptor.getGenPath()));
}
Element models = new Element("models");
ModuleDescriptorPersistence.saveModelRoots(
models, descriptor.getModelRootDescriptors(), macroHelper);
languageElement.addContent(models);
if (!(descriptor.getModuleFacetDescriptors().isEmpty())) {
Element facets = new Element("facets");
ModuleDescriptorPersistence.saveFacets(
facets, descriptor.getModuleFacetDescriptors(), macroHelper);
languageElement.addContent(facets);
}
Element accessoryModels = new Element("accessoryModels");
for (SModelReference model : SetSequence.fromSet(descriptor.getAccessoryModels())) {
XmlUtil.tagWithAttribute(accessoryModels, "model", "modelUID", model.toString());
}
languageElement.addContent(accessoryModels);
Element generators = new Element("generators");
for (GeneratorDescriptor generatorDescriptor :
ListSequence.fromList(descriptor.getGenerators())) {
GeneratorDescriptorPersistence.saveGeneratorDescriptor(
generators, generatorDescriptor, macroHelper);
}
languageElement.addContent(generators);
if (!(descriptor.getAdditionalJavaStubPaths().isEmpty())) {
Element stubModelEntries = new Element("stubModelEntries");
ModuleDescriptorPersistence.saveStubModelEntries(
stubModelEntries, descriptor.getAdditionalJavaStubPaths(), macroHelper);
languageElement.addContent(stubModelEntries);
}
Element sourcePath = new Element("sourcePath");
for (String p : descriptor.getSourcePaths()) {
XmlUtil.tagWithAttribute(sourcePath, "source", "path", macroHelper.shrinkPath(p));
}
languageElement.addContent(sourcePath);
ModuleDescriptorPersistence.saveDependencies(languageElement, descriptor);
Element extendedLanguages = new Element("extendedLanguages");
for (SModuleReference ref : SetSequence.fromSet(descriptor.getExtendedLanguages())) {
XmlUtil.tagWithText(extendedLanguages, "extendedLanguage", ref.toString());
}
languageElement.addContent(extendedLanguages);
try {
OutputStream os = file.openOutputStream();
JDOMUtil.writeDocument(new Document(languageElement), os);
} catch (Exception e) {
if (LOG.isEnabledFor(Priority.ERROR)) {
LOG.error("", e);
}
}
ModuleDescriptorPersistence.setTimestamp(descriptor, file);
}
private List<DepLink> dependencies(DependencyUtil.Role role, SModuleReference moduleRef) {
List<DepLink> result = ListSequence.fromList(new ArrayList<DepLink>());
SModule module = moduleRef.resolve(myRepo);
ModuleDescriptor descr = ((AbstractModule) module).getModuleDescriptor();
if (descr == null) {
return result;
}
switch (role) {
case OwnedGenerator:
case None:
// first step
addDeps(
result,
descr.getUsedDevkits(),
DependencyUtil.Role.UsedDevkit,
DependencyUtil.LinkType.UsesDevkit);
for (SLanguage lang : module.getUsedLanguages()) {
SModule langModule = lang.getSourceModule();
if (langModule != null) {
ListSequence.fromList(result)
.addElement(
new DepLink(
langModule.getModuleReference(),
DependencyUtil.Role.UsedLanguage,
DependencyUtil.LinkType.UsesLanguage));
}
}
for (SDependency dep : module.getDeclaredDependencies()) {
switch (dep.getScope()) {
case EXTENDS:
SModule t = dep.getTarget();
if (t instanceof Language) {
ListSequence.fromList(result)
.addElement(
new DepLink(
dep.getTargetModule(),
DependencyUtil.Role.RegularDependency,
DependencyUtil.LinkType.ExtendsLanguage));
} else if (t instanceof Generator) {
ListSequence.fromList(result)
.addElement(
new DepLink(
dep.getTargetModule(),
DependencyUtil.Role.RegularDependency,
DependencyUtil.LinkType.ExtendsGenerator));
} else {
// just in case module could not be resolved
ListSequence.fromList(result)
.addElement(
new DepLink(
dep.getTargetModule(),
DependencyUtil.Role.RegularDependency,
DependencyUtil.LinkType.Depends));
}
break;
case DESIGN:
ListSequence.fromList(result)
.addElement(
new DepLink(
dep.getTargetModule(),
DependencyUtil.Role.RegularDependency,
DependencyUtil.LinkType.Depends));
break;
case RUNTIME:
ListSequence.fromList(result)
.addElement(
new DepLink(
dep.getTargetModule(),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.Depends));
break;
default:
ListSequence.fromList(result)
.addElement(
new DepLink(
dep.getTargetModule(),
DependencyUtil.Role.RegularDependency,
(dep.isReexport()
? DependencyUtil.LinkType.ReexportsDep
: DependencyUtil.LinkType.Depends)));
}
}
if (module instanceof Language) {
// generators and generators dependencies are now also added to language dependencies
// (MPS-15883)
for (Generator g : ((Language) module).getGenerators()) {
ListSequence.fromList(result)
.addElement(
new DepLink(
g.getModuleReference(),
DependencyUtil.Role.OwnedGenerator,
DependencyUtil.LinkType.Generator));
}
}
if (module instanceof Generator) {
Language srcLang = ((Generator) module).getSourceLanguage();
ListSequence.fromList(result)
.addElement(
new DepLink(
srcLang.getModuleReference(),
DependencyUtil.Role.SourceLanguage,
DependencyUtil.LinkType.GeneratorLanguage));
}
break;
case UsedDevkit:
// explicit use of devkit
case DependencyDevkit:
DevkitDescriptor devkit = as_he47wm_a0a0a3e0g(descr, DevkitDescriptor.class);
if (devkit == null) {
break;
}
boolean direct = role == DependencyUtil.Role.UsedDevkit;
addDeps(
result,
devkit.getExtendedDevkits(),
(direct ? DependencyUtil.Role.UsedDevkit : DependencyUtil.Role.DependencyDevkit),
DependencyUtil.LinkType.ExtendsDevkit);
addDeps(
result,
devkit.getExportedLanguages(),
(direct ? DependencyUtil.Role.UsedLanguage : DependencyUtil.Role.DependencyLanguage),
DependencyUtil.LinkType.ExportsLanguage);
addDeps(
result,
devkit.getExportedSolutions(),
(direct
? DependencyUtil.Role.RegularDependency
: DependencyUtil.Role.RuntimeDependency),
DependencyUtil.LinkType.ExportsSolution);
break;
case UsedLanguage:
LanguageDescriptor lang = as_he47wm_a0a0a4e0g(descr, LanguageDescriptor.class);
if (lang == null) {
break;
}
addDeps(
result,
lang.getExtendedLanguages(),
DependencyUtil.Role.UsedLanguage,
DependencyUtil.LinkType.ExtendsLanguage);
if (myNeedRuntime) {
addDeps(
result,
lang.getRuntimeModules(),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.ExportsRuntime);
}
break;
case RegularDependency:
addDeps(
result,
getReexportDeps(descr),
DependencyUtil.Role.RegularDependency,
DependencyUtil.LinkType.ReexportsDep);
if (descr instanceof LanguageDescriptor) {
addDeps(
result,
(as_he47wm_a0a1a0a1a5e0g(descr, LanguageDescriptor.class)).getExtendedLanguages(),
DependencyUtil.Role.RegularDependency,
DependencyUtil.LinkType.ExtendsLanguage);
}
if (myNeedRuntime) {
addDeps(
result,
getNonreexportDeps(descr),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.Depends);
addDeps(
result,
descr.getUsedLanguages(),
DependencyUtil.Role.DependencyLanguage,
DependencyUtil.LinkType.UsesLanguage);
addDeps(
result,
descr.getUsedDevkits(),
DependencyUtil.Role.DependencyDevkit,
DependencyUtil.LinkType.UsesDevkit);
}
break;
case RuntimeDependency:
if (myNeedRuntime) {
addDeps(
result,
getReexportDeps(descr),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.ReexportsDep);
addDeps(
result,
getNonreexportDeps(descr),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.Depends);
addDeps(
result,
descr.getUsedLanguages(),
DependencyUtil.Role.DependencyLanguage,
DependencyUtil.LinkType.UsesLanguage);
addDeps(
result,
descr.getUsedDevkits(),
DependencyUtil.Role.DependencyDevkit,
DependencyUtil.LinkType.UsesDevkit);
if (descr instanceof LanguageDescriptor) {
addDeps(
result,
(as_he47wm_a0a1a0a4a0a6e0g(descr, LanguageDescriptor.class)).getExtendedLanguages(),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.ExtendsLanguage);
}
if (descr instanceof GeneratorDescriptor) {
GeneratorDescriptor gen = (GeneratorDescriptor) descr;
// generator languages are now also dependencies
addDeps(
result,
gen.getDepGenerators(),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.DependsOnGenerator);
ListSequence.fromList(result)
.addElement(
new DepLink(
(as_he47wm_a0a0a0a0a3a5a0a6e0g(module, Generator.class))
.getSourceLanguage()
.getModuleReference(),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.GeneratorLanguage));
}
}
break;
case SourceLanguage:
// dependency from generator to its source language
addDeps(
result,
check_he47wm_b0b0h4a6(as_he47wm_a0b0b0h4a6(descr, LanguageDescriptor.class)),
DependencyUtil.Role.SourceLanguage,
DependencyUtil.LinkType.ExtendsLanguage);
addDeps(
result,
check_he47wm_b0c0h4a6(as_he47wm_a0b0c0h4a6(descr, LanguageDescriptor.class)),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.ExportsRuntime);
break;
case DependencyLanguage:
addDeps(
result,
check_he47wm_b0a0i4a6(as_he47wm_a0b0a0i4a6(descr, LanguageDescriptor.class)),
DependencyUtil.Role.DependencyLanguage,
DependencyUtil.LinkType.ExtendsLanguage);
addDeps(
result,
check_he47wm_b0b0i4a6(as_he47wm_a0b0b0i4a6(descr, LanguageDescriptor.class)),
DependencyUtil.Role.RuntimeDependency,
DependencyUtil.LinkType.ExportsRuntime);
break;
default:
}
return result;
}
private static Set<SModuleReference> check_he47wm_b0b0i4a6(LanguageDescriptor checkedDotOperand) {
if (null != checkedDotOperand) {
return checkedDotOperand.getRuntimeModules();
}
return null;
}
