public static List<SModelDescriptor> getLanguageModels(Language lang) {
List<SModelDescriptor> inputModels = new ArrayList<SModelDescriptor>();
for (LanguageAspect aspect : LanguageAspect.values()) {
SModelDescriptor model = aspect.get(lang);
if (model != null) {
inputModels.add(model);
}
}
Set<SModelDescriptor> ownModels = new HashSet<SModelDescriptor>(lang.getOwnModelDescriptors());
for (SModelDescriptor sm : lang.getAccessoryModels()) {
if (!SModelStereotype.isUserModel(sm)) continue;
if (!(sm instanceof EditableSModelDescriptor)) continue;
if (ownModels.contains(sm)) {
inputModels.add(((EditableSModelDescriptor) sm));
}
}
inputModels.addAll(lang.getUtilModels());
// add it from all generators
List<Generator> list = lang.getGenerators();
for (Generator generator : list) {
inputModels.addAll(generator.getGeneratorModels());
}
return inputModels;
}
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 static SModule getModuleForModel(MPSProject project, SModel model) {
// language's and solution's own models (+generator models in language)
SModule owner = model.getModule();
SModule mainModule =
owner instanceof Generator ? ((Generator) owner).getSourceLanguage() : owner;
if (project.isProjectModule(mainModule)) return owner;
// accessories models in languages
/*
//with this enabled, alt-f1 does not work in case node is in non-owned accessory model to a project language
for (Language l : project.getProjectLanguages()) {
if (l.isAccessoryModel(model.getSModelReference())) return l;
}
*/
// runtime models in languages
for (Language l : project.getProjectModules(Language.class)) {
for (SModuleReference depModule : l.getRuntimeModulesReferences()) {
if (depModule.equals(mainModule.getModuleReference())) return owner;
}
}
// accessories models in devkits
// runtime models in devkits
return owner;
}
@Override
public SearchResults find(SearchQuery query, @NotNull ProgressMonitor monitor) {
SearchResults<SNode> searchResults = new SearchResults<SNode>();
Object value = query.getObjectHolder().getObject();
SModule module = null;
if (value instanceof SModule) {
module = ((SModule) value);
} else if (value instanceof SModuleReference) {
module = query.getScope().resolve(((SModuleReference) value));
}
if (!(module instanceof Language)) {
return searchResults;
}
Language language = (Language) module;
SModel structureModel = language.getStructureModelDescriptor();
if (structureModel == null) {
return searchResults;
}
if (!(structureModel.getRootNodes().iterator().hasNext())) {
return searchResults;
}
List<SNode> roots = new LinkedList<SNode>();
for (SNode root : structureModel.getRootNodes()) {
roots.add(root);
}
searchResults.getSearchedNodes().addAll(roots);
monitor.start("", IterableUtil.asCollection(structureModel.getRootNodes()).size() + 1);
try {
SearchResults<SModel> modelResults =
FindUtils.getSearchResults(
monitor.subTask(1),
new SearchQuery(
structureModel.getReference(), GlobalScopeMinusTransient.getInstance()),
new ModelImportsUsagesFinder());
List<SModel> models = new ArrayList<SModel>();
for (SearchResult<SModel> sModelSearchResult : modelResults.getSearchResults()) {
models.add(sModelSearchResult.getObject());
}
SearchScope scope = new ModelsScope(models.toArray(new SModel[models.size()]));
SearchResults<SNode> results = new SearchResults();
for (SNode node : roots) {
if (monitor.isCanceled()) {
break;
}
results.addAll(
FindUtils.getSearchResults(
monitor.subTask(1),
node,
scope,
"jetbrains.mps.lang.structure.findUsages.NodeUsages_Finder"));
results.removeDuplicates();
}
searchResults.getSearchResults().addAll(results.getSearchResults());
return searchResults;
} finally {
monitor.done();
}
}
@Override
protected List<SModuleReference> getAllVisibleElements() {
final List<SModuleReference> allLanguages = new ArrayList<SModuleReference>();
for (Language language : ModuleRepositoryFacade.getInstance().getAllModules(Language.class)) {
allLanguages.add(language.getModuleReference());
}
return allLanguages;
}
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);
}
public static void checkBehaviorAspectPresence(Language lang, List<String> errors) {
for (Language language : LanguageDependenciesManager.getAllExtendedLanguages(lang)) {
EditableSModel descriptor = LanguageAspect.BEHAVIOR.get(language);
if (descriptor == null) {
if (lang == language) errors.add("Behavior aspect is absent");
else
errors.add("Cannot extend language without behavior aspect: " + language.getModuleName());
}
}
}
public SearchResults find(SearchQuery query, ProgressMonitor monitor) {
SearchResults<SNode> searchResults = new SearchResults<SNode>();
IHolder holder = query.getObjectHolder();
assert holder instanceof ModuleHolder;
IModule module = ((ModuleHolder) holder).getObject();
assert module instanceof Language;
Language language = (Language) module;
SModelDescriptor structureModel = language.getStructureModelDescriptor();
if (structureModel == null) {
return searchResults;
}
SModel sModel = structureModel.getSModel();
if (sModel == null) {
return searchResults;
}
if (sModel.rootsCount() == 0) {
return searchResults;
}
List<SNode> roots = new LinkedList<SNode>();
for (SNode root : sModel.roots()) {
roots.add(root);
}
searchResults.getSearchedNodes().addAll(roots);
monitor.start("", sModel.rootsCount() + 1);
try {
SearchResults<SModel> modelResults =
FindUtils.getSearchResults(
monitor.subTask(1),
new SearchQuery(sModel, GlobalScopeMinusTransient.getInstance()),
new ModelUsagesFinder());
List<SModelDescriptor> models = new ArrayList<SModelDescriptor>();
for (SearchResult<SModel> sModelSearchResult : modelResults.getSearchResults()) {
models.add(sModelSearchResult.getObject().getModelDescriptor());
}
IScope scope = new ModelsOnlyScope(models.toArray(new SModelDescriptor[models.size()]));
SearchResults results = new SearchResults();
for (SNode node : roots) {
if (monitor != null && monitor.isCanceled()) {
break;
}
results.addAll(
FindUtils.getSearchResults(
monitor.subTask(1),
node,
scope,
"jetbrains.mps.lang.structure.findUsages.NodeUsages_Finder"));
results.removeDuplicates();
}
searchResults.getSearchResults().addAll(results.getSearchResults());
return searchResults;
} finally {
monitor.done();
}
}
@Test
public void testUsedLanguageDependencyNotInScope() {
Solution s1 = createSolution();
Solution ld = createSolution();
Language l1 = createLanguage();
l1.addDependency(ld.getModuleReference(), true);
s1.addUsedLanguage(l1.getModuleReference());
assertFalse(new GlobalModuleDependenciesManager(s1).getModules(Deptype.VISIBLE).contains(ld));
assertFalse(IterableUtil.asCollection(s1.getScope().getVisibleModules()).contains(ld));
}
private Class<KeyMap> findKeyMapClassByDeclaration(SNode declaration) {
String fqName =
BehaviorReflection.invokeVirtual(
String.class, declaration, "virtual_getFqName_1213877404258", new Object[] {});
String namespace = NameUtil.namespaceFromLongName(fqName);
assert namespace.endsWith(".editor");
String languageNamespace = namespace.substring(0, namespace.length() - ".editor".length());
Language language =
(Language) MPSModuleRepository.getInstance().getModuleByFqName(languageNamespace);
if (language == null) {
return null;
}
return language.getClass(fqName);
}
@Override
public List<String> getWarnings() {
List<String> warnings = new ArrayList<String>(super.getWarnings());
Set<String> usedLanguages = new HashSet<String>();
for (SModel model : myModule.getOwnTemplateModels()) {
if (SModelStereotype.isGeneratorModel(model)) {
usedLanguages.addAll(ModelContentUtil.getUsedLanguageNamespacesInTemplateModel(model));
}
}
Set<String> extendedLanguages = new HashSet<String>();
Language sourceLanguage = myModule.getSourceLanguage();
usedLanguages.remove(sourceLanguage.getModuleName());
Set<Language> ext = new LinkedHashSet<Language>();
sourceLanguage.getDependenciesManager().collectAllExtendedLanguages(ext);
for (Language language : ext) {
extendedLanguages.add(language.getModuleName());
}
for (String lang : usedLanguages) {
Language language = ModuleRepositoryFacade.getInstance().getModule(lang, Language.class);
if (language == null) continue;
if (!extendedLanguages.contains(lang) && !language.getRuntimeModulesReferences().isEmpty()) {
warnings.add(sourceLanguage + " should extend " + lang);
}
}
return warnings;
}
public static Iterable sourceNodesQuery_7923290658387314672(
final IOperationContext operationContext, final SourceSubstituteMacroNodesContext _context) {
SModel behaviorModel = _context.getOriginalInputModel();
Language language = Language.getLanguageForLanguageAspect(behaviorModel);
SModel structureModel = LanguageAspect.STRUCTURE.get(language);
return SModelOperations.getNodes(
structureModel, "jetbrains.mps.lang.structure.structure.AbstractConceptDeclaration");
}
public static boolean checkCyclicInheritance(Language lang) {
List<Language> frontier = ModuleUtil.refsToLanguages(lang.getExtendedLanguageRefs());
ArrayList<Language> passed = new ArrayList<Language>();
while (!frontier.isEmpty()) {
List<Language> newFrontier = new ArrayList<Language>();
for (Language extendedLang : frontier) {
if (extendedLang == lang && lang != BootstrapLanguages.coreLanguage()) {
return false;
}
if (!passed.contains(extendedLang)) {
newFrontier.addAll(ModuleUtil.refsToLanguages(extendedLang.getExtendedLanguageRefs()));
}
passed.add(extendedLang);
}
frontier = newFrontier;
}
return true;
}
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 Iterable sourceNodesQuery_1220369573364040170(
final IOperationContext operationContext, final SourceSubstituteMacroNodesContext _context) {
List<SNode> result = new ArrayList<SNode>();
List<Language> langs =
SModelOperations.getLanguages(
SNodeOperations.getModel(_context.getNode()), GlobalScope.getInstance());
for (Language lang : langs) {
for (ModuleReference mr : lang.getRuntimeModulesReferences()) {
for (SModelDescriptor smd :
MPSModuleRepository.getInstance().getModule(mr).getOwnModelDescriptors()) {
SModel rtModel = smd.getSModel();
for (SNode gwtmod :
jetbrains.mps.lang.smodel.generator.smodelAdapter.SModelOperations.getRoots(
rtModel, "jetbrains.mps.gwt.client.structure.GWTModule")) {
ListSequence.fromList(result).addElement(gwtmod);
}
}
}
}
return result;
}
protected void addBuiltInImports() {
SLanguage base =
MetaAdapterFactory.getLanguage(
MetaIdFactory.langId(0xde1ad86d6e504a02L, 0xb306d4d17f64c375L),
"jetbrains.mps.console.base");
Collection<SLanguage> baseAndExtensions =
new SLanguageHierarchy(Collections.singleton(base)).getExtending();
SModelInternal modelInternal = ((SModelInternal) myModel);
for (SLanguage l : CollectionSequence.fromCollection(baseAndExtensions)) {
modelInternal.addLanguage(l);
Language sourceLangModule = (Language) l.getSourceModule();
if (sourceLangModule == null) {
continue;
}
modelInternal.addModelImport(
sourceLangModule.getStructureModelDescriptor().getReference(), false);
((AbstractModule) myModel.getModule())
.addDependency(sourceLangModule.getModuleReference(), false);
}
modelInternal.addDevKit(
PersistenceFacade.getInstance()
.createModuleReference(
"fbc25dd2-5da4-483a-8b19-70928e1b62d7(jetbrains.mps.devkit.general-purpose)"));
}
public static Iterable sourceNodesQuery_2056529430201935318(
final IOperationContext operationContext, final SourceSubstituteMacroNodesContext _context) {
SModel behaviorModel = _context.getOriginalInputModel();
Language language = Language.getLanguageForLanguageAspect(behaviorModel);
SModel structureModel = LanguageAspect.STRUCTURE.get(language);
return ListSequence.fromList(
SModelOperations.getNodes(
structureModel, "jetbrains.mps.lang.structure.structure.ConceptDeclaration"))
.where(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return !(SPropertyOperations.getBoolean(it, "abstract"));
}
});
}
public RenameLanguageDialog(Project project, Language language) throws HeadlessException {
super(project, language.getModuleFqName(), "language");
myLanguage = language;
myProject = project;
setTitle("Rename Language");
myRegenerateLanguage
.getModel()
.setSelected(
ModelAccess.instance()
.runReadAction(
new Computable<Boolean>() {
@Override
public Boolean compute() {
return !(myLanguage.isBootstrap());
}
}));
}
public RenameLanguageDialog(com.intellij.openapi.project.Project project, Language language)
throws HeadlessException {
super(project, language.getModuleName(), "language");
myLanguage = language;
myProject = ProjectHelper.toMPSProject(project);
setTitle("Rename Language");
final boolean[] regenerateHolder = new boolean[] {false};
myProject
.getRepository()
.getModelAccess()
.runReadAction(
new Runnable() {
public void run() {
regenerateHolder[0] = !(myLanguage.isBootstrap());
}
});
myRegenerateLanguage.getModel().setSelected(regenerateHolder[0]);
}
public int getModelKind(SModel model, @Nullable SReference reference) {
DataSource source = (model != null ? model.getSource() : null);
IFile modelFile =
(source instanceof FileDataSource ? ((FileDataSource) source).getFile() : null);
if (modelFile != null) {
String filePath = modelFile.getAbsolutePath().replace('\\', '/');
if (filePath.startsWith(languagesUtilPath)) {
return OTHER;
}
}
SModule module = model.getModule();
if (module instanceof Language) {
LanguageAspect aspect = Language.getModelAspect(model);
if (aspect != null) {
switch (aspect) {
case ACTIONS:
return EDITOR;
case BEHAVIOR:
return CORE;
case CONSTRAINTS:
return CORE;
case DATA_FLOW:
return CORE;
case EDITOR:
return EDITOR;
case FIND_USAGES:
return CORE;
case INTENTIONS:
return EDITOR;
case PLUGIN:
return WORKBENCH;
case REFACTORINGS:
return CORE;
case SCRIPTS:
return CORE;
case STRUCTURE:
return CORE;
case STUBS:
return CORE;
case TEST:
return EDITOR;
case TEXT_GEN:
return CORE;
case TYPESYSTEM:
return CORE;
default:
}
}
return CORE;
} else if (module instanceof Solution) {
String moduleFqName = module.getModuleName();
if (moduleFqName.equals("JDK")) {
return CORE;
}
if (moduleFqName.equals("MPS.Core")) {
return CORE;
}
if (moduleFqName.equals("MPS.Editor")) {
return EDITOR;
}
if (moduleFqName.equals("MPS.Workbench")) {
return WORKBENCH;
}
if (moduleFqName.equals("MPS.Classpath")) {
SNode refTargetRoot = reference.getTargetNode().getContainingRoot();
if (SNodeOperations.isInstanceOf(
refTargetRoot, "jetbrains.mps.baseLanguage.structure.Classifier")) {
String cName =
SPropertyOperations.getString(
SNodeOperations.cast(
refTargetRoot, "jetbrains.mps.baseLanguage.structure.Classifier"),
"name");
String modelName = model.getModelName();
if (findInModule(coreModule, modelName, cName)) {
return CORE;
}
if (findInModule(editorModule, modelName, cName)) {
return EDITOR;
}
return WORKBENCH;
}
return OTHER;
}
Solution sol = (Solution) module;
switch (sol.getKind()) {
case NONE:
return OTHER;
case PLUGIN_CORE:
return CORE;
case PLUGIN_EDITOR:
return EDITOR;
case PLUGIN_OTHER:
return WORKBENCH;
default:
}
}
return OTHER;
}
public MPSLanguageVirtualFile(@NotNull Language language) {
myLanguage = language;
myPath = myLanguage.getModuleFqName();
myName = myLanguage.getModuleFqName();
}
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 EditableSModel getPluginModel(Language lang) {
SModel plugin = LanguageAspect.PLUGIN.get(lang);
LanguageAspect aspectForModel = lang.getAspectForModel(plugin);
return aspectForModel.getOrCreate(lang);
}
public static void copyLanguageJSAccessories(Language language, String targetSourcePath) {
copyLanguageJSAccessories(language.getBundleHome().getPath(), targetSourcePath);
}
@Override
public void doUpdate(AnActionEvent event) {
removeAll();
SModel modelDescriptor = event.getData(MPSDataKeys.CONTEXT_MODEL);
if (modelDescriptor == null) {
setEnabledState(event.getPresentation(), false);
return;
}
if (!(modelDescriptor instanceof EditableSModel)
|| (((EditableSModel) modelDescriptor).isReadOnly())) {
event.getPresentation().setEnabled(false);
event.getPresentation().setVisible(false);
return;
}
IScope scope = event.getData(MPSDataKeys.SCOPE);
IOperationContext context = event.getData(MPSDataKeys.OPERATION_CONTEXT);
boolean isStubModel =
SModelStereotype.isStubModelStereotype(SModelStereotype.getStereotype(modelDescriptor));
if (scope == null || context == null || isStubModel) {
setEnabledState(event.getPresentation(), false);
return;
}
boolean inEditor = event.getData(MPSDataKeys.LOGICAL_VIEW_SELECTION_SIZE) == null;
if (!inEditor) {
Integer selectedItemsCount = event.getData(MPSDataKeys.LOGICAL_VIEW_SELECTION_SIZE);
boolean singleItemSelected = selectedItemsCount != null && selectedItemsCount == 1;
if (!singleItemSelected) {
setEnabledState(event.getPresentation(), false);
return;
}
TreeNode treeNode = event.getData(MPSDataKeys.LOGICAL_VIEW_NODE);
if (!(treeNode instanceof PackageNode)) {
myPackage = null;
} else {
final PackageNode node = (PackageNode) treeNode;
myPackage = node.getPackage();
}
} else {
SNode node = event.getData(MPSDataKeys.NODE);
myPackage = null;
if (node != null) {
SNode root = node.getContainingRoot();
myPackage =
SNodeAccessUtil.getProperty(root, SNodeUtil.property_BaseConcept_virtualPackage);
}
}
setEnabledState(event.getPresentation(), true);
List<Language> modelLanguages = SModelOperations.getLanguages(modelDescriptor, scope);
LanguageAspect aspect = Language.getModelAspect(modelDescriptor);
if (aspect != null) {
SModuleReference ref = aspect.getMainLanguage();
Language lang = scope.getLanguage(ref);
if (lang != null) {
modelLanguages.remove(lang);
for (SNode conceptDeclaration : lang.getConceptDeclarations()) {
if (ModelConstraintsManager.canBeRoot(
context, NameUtil.nodeFQName(conceptDeclaration), modelDescriptor)) {
add(
new NewRootNodeAction(
new jetbrains.mps.smodel.SNodePointer(conceptDeclaration), modelDescriptor));
}
}
addSeparator();
}
}
Collections.sort(modelLanguages, new ToStringComparator());
List<Language> languagesWithRoots = new ArrayList<Language>();
for (final Language language : modelLanguages) {
for (SNode conceptDeclaration : language.getConceptDeclarations()) {
if (ModelConstraintsManager.canBeRoot(
context, NameUtil.nodeFQName(conceptDeclaration), modelDescriptor)) {
languagesWithRoots.add(language);
break;
}
}
}
boolean plain = myPlain || (languagesWithRoots.size() == 1 && aspect == null);
for (final Language language : languagesWithRoots) {
String name = language.getModuleName();
Icon icon = IconManager.getIconForNamespace(language.getModuleName());
BaseGroup langRootsGroup;
if (!plain) {
langRootsGroup = new BaseGroup(NameUtil.compactNamespace(name), name, icon);
langRootsGroup.setPopup(true);
} else {
langRootsGroup = this;
}
for (SNode conceptDeclaration : language.getConceptDeclarations()) {
if (ModelConstraintsManager.getInstance()
.canBeRoot(context, NameUtil.nodeFQName(conceptDeclaration), modelDescriptor)) {
langRootsGroup.add(
new NewRootNodeAction(
new jetbrains.mps.smodel.SNodePointer(conceptDeclaration), modelDescriptor));
}
}
if (!plain) {
this.add(langRootsGroup);
} else {
this.addSeparator();
}
}
if (getChildrenCount() == 0) {
add(
ActionManager.getInstance()
.getAction(
"jetbrains.mps.ide.editor.actions.AddLanguageImport_Action" /* FIXME AddLanguageImport_Action.class.getName()*/));
}
}
public static SModelDescriptor getOptional(Language l) {
SModelReference modelRef =
SModelReference.fromString(LANGUAGE_NAMESPACE + OPTIONAL_MODEL_SUFFIX);
return l.getScope().getModelDescriptor(modelRef);
}
public static SModelDescriptor getGenerated(Language l) {
SModelReference modelRef =
SModelReference.fromString(LANGUAGE_NAMESPACE + GENERATED_MODEL_SUFFIX);
return l.getScope().getModelDescriptor(modelRef);
}