@Override public List<String> getErrors() { List<String> errors = new ArrayList<String>(); Throwable loadException = myModule.getModuleDescriptor().getLoadException(); if (loadException != null) { errors.add("Couldn't load module: " + loadException.getMessage()); return errors; } ModuleDescriptor descriptor = myModule.getModuleDescriptor(); // null? for (Dependency dep : descriptor.getDependencies()) { SModuleReference moduleRef = dep.getModuleRef(); if (MPSModuleRepository.getInstance().getModule(moduleRef) == null) { errors.add("Can't find dependency: " + moduleRef.getModuleName()); } } for (SModuleReference reference : descriptor.getUsedLanguages()) { if (ModuleRepositoryFacade.getInstance().getModule(reference, Language.class) == null) { errors.add("Can't find used language: " + reference.getModuleName()); } } for (SModuleReference reference : descriptor.getUsedDevkits()) { if (MPSModuleRepository.getInstance().getModule(reference) == null) { errors.add("Can't find used devkit: " + reference.getModuleName()); } } if (descriptor.getSourcePaths() != null && !myModule.isPackaged()) { for (String sourcePath : descriptor.getSourcePaths()) { IFile file = FileSystem.getInstance().getFileByPath(sourcePath); if (file == null || !file.exists()) { errors.add("Can't find source path: " + sourcePath); } } } if (descriptor.getAdditionalJavaStubPaths() != null) { for (String path : descriptor.getAdditionalJavaStubPaths()) { IFile file = FileSystem.getInstance().getFileByPath(path); if (file == null || !file.exists()) { if (new File(path).exists()) { errors.add("Idea VFS is not up-to-date. Can't find library: " + path); } else { errors.add("Can't find library: " + path); } } } } // todo: =( if (!(myModule instanceof Generator)) { errors.addAll(validateDependenciesOnGenerators()); } return errors; }
protected void removeSolution(String name) { ModuleReference ref = new ModuleReference(null, ModuleId.foreign(name)); MPSModuleRepository repository = MPSModuleRepository.getInstance(); IModule m = ModuleRepositoryFacade.getInstance().getModule(ref); if (m == null) { return; } repository.unregisterModule(m, this); }
protected void removeSolution(String name) { SModuleReference ref = new jetbrains.mps.project.structure.modules.ModuleReference(null, ModuleId.foreign(name)); MPSModuleRepository repository = MPSModuleRepository.getInstance(); SModule m = ModuleRepositoryFacade.getInstance().getModule(ref); if (m == null) { return; } repository.unregisterModule(m, this); }
@Override public void write(Element element, Project project) throws CantSaveSomethingException { super.write(element, project); if (myNodePointer.resolve(MPSModuleRepository.getInstance()) != null) { Element nodeXML = new Element(NODE); nodeXML.addContent( ComponentsUtil.nodeToElement(myNodePointer.resolve(MPSModuleRepository.getInstance()))); element.addContent(nodeXML); } else { throw new CantSaveSomethingException(); } }
@NotNull public static List<IModule> getVisibleModules_4040588429969394431(IScope scope) { List<IModule> result = ListSequence.fromList(new ArrayList<IModule>()); ListSequence.fromList(result) .addSequence(SetSequence.fromSet(MPSModuleRepository.getInstance().getAllModules())); return result; }
public static List<DefaultActionGroup> getCreateGroups( SNodeReference baseNode, Collection<RelationDescriptor> possibleTabs, @Nullable RelationDescriptor currentAspect, NodeChangeCallback callback) { List<DefaultActionGroup> groups = new ArrayList<DefaultActionGroup>(); List<RelationDescriptor> tabs = new ArrayList<RelationDescriptor>(possibleTabs); Collections.sort(tabs, new RelationComparator()); if (currentAspect != null) { tabs.remove(currentAspect); tabs.add(0, currentAspect); } for (final RelationDescriptor d : tabs) { List<SNode> nodes = d.getNodes(baseNode.resolve(MPSModuleRepository.getInstance())); if (!nodes.isEmpty() && d.isSingle()) continue; DefaultActionGroup group = getCreateGroup(baseNode, callback, d); if (group == null) continue; if (tabs.indexOf(d) == 0) { group.setPopup(false); } groups.add(group); } return groups; }
public SNode getTemplateNodeForLogging() { return myScript != null ? myScript : myScriptPointer != null ? myScriptPointer.resolve(MPSModuleRepository.getInstance()) : null; }
protected boolean checkLibraryName(String libraryName) { if (MPSModuleRepository.getInstance().getModuleByUID(libraryName) != null) { myThis.getDialog().setErrorText("Duplicate library name: " + libraryName); return false; } return true; }
CodeOrchestraStreamHandler( SModelDescriptor modelDescriptor, IFile outputDir, CodeOrchestraGenerationFileProcessor processor) { myOriginalOutputDir = outputDir; CodeOrchestraGenerateManager codeOrchestraGenerateManager = processor.getProject().getComponent(CodeOrchestraGenerateManager.class); CodeOrchestraGenerationContext currentContext = codeOrchestraGenerateManager.getCurrentContext(); if (currentContext == null) { myOutputDir = outputDir; myCachesOutputDir = FileGenerationUtil.getCachesDir(outputDir); } else { ModuleReference rootModuleReference = currentContext.getRootModule(); // We override the output path for the AS & JS modules if (currentContext.isSingleOutputContext()) { IModule rootModule = MPSModuleRepository.getInstance().getModule(rootModuleReference); myOutputDir = FileSystem.getInstance().getFileByPath(rootModule.getOutputFor(modelDescriptor)); myCachesOutputDir = FileGenerationUtil.getCachesDir(myOutputDir); } else { myOutputDir = outputDir; myCachesOutputDir = FileGenerationUtil.getCachesDir(outputDir); } } myModelDescriptor = modelDescriptor; myProcessor = processor; }
@Nullable public static IModule call_getModule_4040588429969043137(SNode thisNode) { if (SPropertyOperations.getString(thisNode, "moduleId") == null) { return null; } return MPSModuleRepository.getInstance() .getModuleById(ModuleId.fromString(SPropertyOperations.getString(thisNode, "moduleId"))); }
@Override protected void doNavigate(boolean focus) { IModule module = MPSModuleRepository.getInstance().getModule(moduleReference); if (module == null) return; ModuleContext context = new ModuleContext(module, project); NavigationSupport.getInstance().selectInTree(context, module, focus); }
public String getItemLabel(Object value) { ModuleReference moduleReference = (ModuleReference) value; final IModule module = MPSModuleRepository.getInstance().getModule(moduleReference); if (module == null) { String moduleName = moduleReference.getModuleFqName(); return (moduleName.equals("") ? "<no name>" : moduleName); } return moduleReference.getModuleFqName(); }
protected void addListeners() { VirtualFileManager.getInstance().addVirtualFileManagerListener(myRefreshListener); SModelRepository.getInstance().addModelRepositoryListener(mySModelRepositoryListener); ModelAccess.instance().addCommandListener(myModelAccessListener); MPSModuleRepository.getInstance().addModuleRepositoryListener(myRepositoryListener); if (IMakeService.INSTANCE.isSessionActive()) { IMakeService.INSTANCE.get().addListener(myMakeNotificationListener); } ClassLoaderManager.getInstance().addReloadHandler(myReloadListener); }
protected void removeListeners() { ClassLoaderManager.getInstance().removeReloadHandler(myReloadListener); SModelRepository.getInstance().removeModelRepositoryListener(mySModelRepositoryListener); ModelAccess.instance().removeCommandListener(myModelAccessListener); MPSModuleRepository.getInstance().removeModuleRepositoryListener(myRepositoryListener); if (IMakeService.INSTANCE.hasMakeService()) { IMakeService.INSTANCE.get().removeListener(myMakeNotificationListener); } VirtualFileManager.getInstance().removeVirtualFileManagerListener(myRefreshListener); }
@Override public boolean canExecute(EditorContext context) { Selection selection = context.getSelectionManager().getSelection(); List<SNode> pasteNodes = CopyPasteUtil.getNodesFromClipboard(selection.getSelectedNodes().get(0).getModel()); if (pasteNodes == null || pasteNodes.isEmpty()) { // it used to be ok because conversion would be invoked in this case return false; } boolean disposed = false; for (SNode node : selection.getSelectedNodes()) { if (!SNodeUtil.isAccessible(node, MPSModuleRepository.getInstance())) { disposed = true; break; } } boolean canPasteWithRemove = !disposed && canPasteViaNodePasterWithRemove(selection.getSelectedNodes(), pasteNodes); if (selection instanceof SingularSelection && (selection instanceof EditorCellLabelSelection && !isCompletelySelected((EditorCellLabelSelection) selection) || (selection instanceof EditorCellSelection && !canPasteWithRemove))) { EditorCell selectedCell = getCellToPasteTo(context.getSelectedCell()); if (selectedCell == null) { return false; } SNode selectedNode = selectedCell.getSNode(); if (selectedNode == null || !(SNodeUtil.isAccessible(selectedNode, MPSModuleRepository.getInstance()))) { return false; } return canPasteViaNodePaster(selectedCell, pasteNodes); } else if ((selection instanceof MultipleSelection || selection instanceof EditorCellSelection) && canPasteWithRemove) { return true; } return false; }
@Override public SLink findLink(String role) { SNode ld = new ConceptAndSuperConceptsScope(getConcept().resolve(MPSModuleRepository.getInstance())) .getLinkDeclarationByRole(role); return (ld == null ? null : new SLinkNodeAdapter( SNodeOperations.cast(ld, "jetbrains.mps.lang.structure.structure.LinkDeclaration"))); }
@Override public Iterable<FileSystemListener> getListenerDependencies() { List<FileSystemListener> listeners = new ArrayList<FileSystemListener>(); for (MPSModuleOwner owner : MPSModuleRepository.getInstance().getOwners(this)) { if (owner instanceof FileSystemListener) { listeners.add((FileSystemListener) owner); } } return listeners.isEmpty() ? null : listeners; }
public void createModule(final SModule module) { if (myModuleMap.containsKey(module)) { return; } final TransientModelsModule transientModelsModule = new TransientModelsModule(module, TransientModelsProvider.this); MPSModuleRepository.getInstance().registerModule(transientModelsModule, myOwner); myModuleMap.put(module, transientModelsModule); }
private Set<SNode> getDependenciesToInvalidate(SModel model) { Set<SNode> result = new HashSet<SNode>(); for (SNode dependency : MapSequence.fromMap(myDependenciesToNodes).keySet()) { if (!(SNodeUtil.isAccessible(dependency, MPSModuleRepository.getInstance())) || SNodeOperations.getModel(dependency) == model) { SetSequence.fromSet(result).addElement(dependency); } } return result; }
public StubPath addStubPath(String stubPath) { StubPath path = new StubPath(stubPath, STUBS_MANAGER); if (myStubPaths.contains(path)) { path = null; } else { myStubPaths.add(path); } updateClassPath(); MPSModuleRepository.getInstance().fireModuleChanged(this); return path; }
private EditableSModel getContextModel(AbstractTreeNode selectedNode) { if (selectedNode instanceof MPSPsiElementTreeNode) { MPSPsiNodeBase value = ((MPSPsiElementTreeNode) selectedNode).getValue(); return getModel(value); } else if (selectedNode instanceof MPSPsiModelTreeNode) { MPSPsiModel psiModel = ((MPSPsiModelTreeNode) selectedNode).getModel(); SModel sModel = psiModel.getSModelReference().resolve(MPSModuleRepository.getInstance()); return (EditableSModel) sModel; } return null; }
public void stopListening() { ModelAccess.instance().removeCommandListener(myCommandListener); myNodes.clear(); myModels.clear(); myModules.clear(); GlobalSModelEventsManager.getInstance().removeGlobalCommandListener(myModelListener); SModelRepository.getInstance().removeModelRepositoryListener(myModelRepositoryListener); MPSModuleRepository.getInstance().removeRepositoryListener(myModuleRepositoryListener); }
@Override public Iterable<SDependency> getDeclaredDependencies() { Iterable<SModule> modules = MPSModuleRepository.getInstance().getModules(); return Sequence.fromIterable(modules) .select( new ISelector<SModule, SDependency>() { public SDependency select(SModule it) { return ((SDependency) new SDependencyImpl(it, SDependencyScope.DEFAULT, false)); } }); }
public void modelsReplaced(Set<SModel> replacedModels) { for (SModel md : replacedModels) { if (!myListeningForModels.contains(md)) { continue; } SModelReference modelRef = md.getReference(); synchronized (myLock) { for (SNodeReference nodePointer : new ArrayList<SNodeReference>(myTypeCheckingContexts.keySet())) { if (nodePointer == null) continue; SNode node = nodePointer.resolve(MPSModuleRepository.getInstance()); if (node == null || !SNodeUtil.isAccessible(node, MPSModuleRepository.getInstance()) || modelRef.equals(nodePointer.getModelReference())) { removeContextForNode(nodePointer); } } } } }
public static DefaultActionGroup getCreateGroup( SNodeReference baseNode, NodeChangeCallback callback, RelationDescriptor d) { List<SNode> concepts = d.getConcepts(baseNode.resolve(MPSModuleRepository.getInstance())); if (concepts.isEmpty()) return new DefaultActionGroup(); DefaultActionGroup group = new DefaultActionGroup(d.getTitle(), true); for (final SNode concept : concepts) { group.add(new CreateAction(concept, d, baseNode, callback)); } return group; }
public void doExecute(@NotNull final AnActionEvent event, final Map<String, Object> _params) { try { NodeHighlightManager highlightManager = ((EditorComponent) MapSequence.fromMap(_params).get("editorComponent")) .getHighlightManager(); EditorMessageOwner messageOwner = ((EditorComponent) MapSequence.fromMap(_params).get("editorComponent")) .getHighlightMessagesOwner(); highlightManager.mark( ((EditorCell) MapSequence.fromMap(_params).get("editorCell")).getSNode(), HighlightConstants.NODE_COLOR, "node", messageOwner); Set<SNode> nodes = ((EditorComponent) MapSequence.fromMap(_params).get("editorComponent")) .getNodesCellDependOn(((EditorCell) MapSequence.fromMap(_params).get("editorCell"))); if (nodes != null) { for (SNode node : SetSequence.fromSet(nodes)) { highlightManager.mark(node, HighlightConstants.DEPENDENCY_COLOR, "usage", messageOwner); } } Set<SNodeReference> copyOfRefTargets = ((EditorComponent) MapSequence.fromMap(_params).get("editorComponent")) .getCopyOfRefTargetsCellDependsOn( ((EditorCell) MapSequence.fromMap(_params).get("editorCell"))); if (copyOfRefTargets != null) { for (SNodeReference nodePointer : SetSequence.fromSet(copyOfRefTargets)) { if (((SNodePointer) nodePointer).resolve(MPSModuleRepository.getInstance()) != null) { highlightManager.mark( ((SNodePointer) nodePointer).resolve(MPSModuleRepository.getInstance()), HighlightConstants.DEPENDENCY_COLOR, "usage", messageOwner); } } } highlightManager.repaintAndRebuildEditorMessages(); } catch (Throwable t) { LOG.error("User's action execute method failed. Action:" + "HighlightCellDependencies", t); } }
private boolean checkDisposed(SNodeReference currentSelectedReference, SNode selectedNode) { if (!SNodeUtil.isAccessible(selectedNode, MPSModuleRepository.getInstance())) { LOG.error( "Selected node is disposed: node = " + selectedNode.toString() + " ; node pointer = (" + currentSelectedReference.toString() + ")"); return true; } return false; }
@Override public List<String> getErrors() { List<String> errors = new ArrayList<String>(super.getErrors()); for (SModuleReference lang : myModule.getExtendedLanguageRefs()) { if (MPSModuleRepository.getInstance().getModule(lang) == null) { errors.add("Can't find extended language: " + lang.getModuleName()); } } checkBehaviorAspectPresence(myModule, errors); for (SModuleReference mr : myModule.getRuntimeModulesReferences()) { SModule runtimeModule = MPSModuleRepository.getInstance().getModule(mr); if (runtimeModule == null) continue; if (!(runtimeModule instanceof Solution)) { errors.add("Runtime module " + runtimeModule + " is not a solution"); } } for (SModelReference accessory : myModule.getModuleDescriptor().getAccessoryModels()) { // this check is wrong in common as we don't know what the user wants to do with the acc model // in build. // but I'll not delete it until accessories removal just to have some warning on project // consistency org.jetbrains.mps.openapi.model.SModel accModel = accessory.resolve(MPSModuleRepository.getInstance()); if (accModel == null) continue; if (!VisibilityUtil.isVisible(myModule, accModel)) { errors.add( "Can't find accessory model: " + SModelStereotype.withoutStereotype(accessory.getModelName())); } } for (SModuleReference ref : myModule.getModuleDescriptor().getRuntimeModules()) { if (MPSModuleRepository.getInstance().getModule(ref) == null) { errors.add("Can't find runtime module: " + ref.getModuleName()); } } return errors; }
@Override public Iterable<SProperty> getProperties() { return ListSequence.fromList( SLinkOperations.getTargets( ((SNode) getConcept().resolve(MPSModuleRepository.getInstance())), "propertyDeclaration", true)) .select( new ISelector<SNode, SProperty>() { public SProperty select(SNode it) { return ((SProperty) new SPropertyNodeAdapter(it)); } }); }
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); }