protected void readModules(FileMPSProject.ProjectDescriptor projDesc) { myErrors = null; // load solutions Set<SModuleReference> existingModules = getModuleReferences(); for (Path modulePath : projDesc.getModules()) { String path = modulePath.getPath(); IFile descriptorFile = FileSystem.getInstance().getFileByPath(path); if (descriptorFile.exists()) { ModuleDescriptor descriptor = ModulesMiner.getInstance().loadModuleDescriptor(descriptorFile); if (descriptor != null) { ModulesMiner.ModuleHandle moduleHandle = new ModulesMiner.ModuleHandle(descriptorFile, descriptor); SModule m = ModuleRepositoryFacade.createModule(moduleHandle, this); SModuleReference moduleReference = m.getModuleReference(); if (!(existingModules.remove(moduleReference))) { super.addModule(moduleReference); } } else { error("Can't load module from " + descriptorFile.getPath() + " Unknown file type."); } } else { error("Can't load module from " + descriptorFile.getPath() + " File doesn't exist."); } } for (SModuleReference ref : existingModules) { super.removeModule(ref); } }
public void collectRequired(Iterable<SModule> pool) { Set<SModuleReference> allRequired = SetSequence.fromSetWithValues( new HashSet<SModuleReference>(), Sequence.fromIterable(MapSequence.fromMap(allDeps).values()) .translate( new ITranslator2<ModulesCluster.ModuleDeps, SModuleReference>() { public Iterable<SModuleReference> translate(ModulesCluster.ModuleDeps dep) { return dep.required; } })); List<SModule> available = Sequence.fromIterable(pool).toListSequence(); int atSize; do { atSize = MapSequence.fromMap(allDeps).count(); for (Iterator<SModule> it = ListSequence.fromList(available).iterator(); it.hasNext(); ) { SModule mod = it.next(); SModuleReference mr = mod.getModuleReference(); if (SetSequence.fromSet(allRequired).contains(mr)) { primAdd(mod); SetSequence.fromSet(allRequired) .addSequence(ListSequence.fromList(MapSequence.fromMap(allDeps).get(mr).required)); it.remove(); } } } while (atSize < MapSequence.fromMap(allDeps).count()); }
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 @Nullable public WarningPanel getWarningPanel(@NotNull SNode node, @NotNull Project project) { SModel model = node.getModel(); if (model != null) { SModule module = model.getModule(); if (module != null && module.isReadOnly()) { return new WarningPanel( this, "Warning: the node is in a read-only model. Your changes won't be saved"); } } return null; }
private void primAdd(SModule mod) { SModuleReference mr = mod.getModuleReference(); if (!(MapSequence.fromMap(modulesView).containsKey(mr))) { MapSequence.fromMap(modulesView).put(mr, mod); updateDeps(mod); } }
@Override public Iterable<SModel> loadModels() { List<SModel> result = new ArrayList<SModel>(); Map<String, String> options = new HashMap<String, String>(); String contentHome = getContentRoot(); SModule module = getModule(); if (module != null) { options.put(ModelFactory.OPTION_MODULEREF, module.getModuleReference().toString()); } for (String path : getFiles(SOURCE_ROOTS)) { String relativePath = contentHome != null ? makeRelative(contentHome, path) : null; collectModels( FileSystem.getInstance().getFileByPath(path), "", relativePath, options, result); } return result; }
public RelativePathHelper getRelativePathHelper(@NotNull SModel model) { if (model.getModule() instanceof TransientModelsModule && myGenerationContext != null) { model = myGenerationContext.getOriginalInputModel(); } SModel modelDescriptor = model; if (model.getModule() instanceof TransientModelsModule || modelDescriptor == null) { return null; } SModule module = modelDescriptor.getModule(); if (module == null || ((AbstractModule) module).getDescriptorFile() == null || module.isPackaged()) { return null; } String basePath = ((AbstractModule) module).getDescriptorFile().getParent().getPath(); return new RelativePathHelper(basePath); }
/** * has a fallback if the dependency is absent in the module descriptor. if it happens then returns * simply the current dep. module version * * @param check is whether to show error for not found version */ public int getDependencyVersion(@NotNull SModule dependency, boolean check) { ModuleDescriptor moduleDescriptor = getModuleDescriptor(); if (!checkDescriptorNotNull(moduleDescriptor)) { return -1; } Integer res = moduleDescriptor.getDependencyVersions().get(dependency.getModuleReference()); if (res == null) { if (check) { LOG.error( "#getDependencyVersion can't find a version for module " + dependency.getModuleName() + " in module " + getModuleName() + "." + " This can either mean that the module is not visible from this module or that " + "#validateDependencyVersions() was not called on this module in appropriate moment.", new Throwable()); } return ((AbstractModule) dependency).getModuleVersion(); } return res; }
public void clean(final Set<? extends SModule> modules, @NotNull final ProgressMonitor monitor) { monitor.start("Cleaning...", modules.size()); try { for (SModule module : modules) { if (isExcluded(module)) { monitor.advance(1); continue; } if (monitor.isCanceled()) break; monitor.step(module.getModuleName()); JavaModuleFacet facet = module.getFacet(JavaModuleFacet.class); assert facet != null && facet.getClassesGen() != null; String path = facet.getClassesGen().getPath(); FileUtil.delete(new File(path)); ClassPathFactory.getInstance().invalidate(Collections.singleton(path)); monitor.advance(1); } } finally { monitor.done(); } }
public void handleAction_impl( SModule parameterObject, SNode node, SModel model, IOperationContext operationContext, EditorContext editorContext) { SPropertyOperations.set( node, MetaAdapterFactory.getProperty( 0x7866978ea0f04cc7L, 0x81bc4d213d9375e1L, 0x38130dc4e3db5af1L, 0x38130dc4e3db5af3L, "moduleId"), parameterObject.getModuleReference().getModuleId().toString()); }
public static boolean findInModule(SModule module, String modelName, String rootName) { for (SModel d : module.getModels()) { if (d.getModelName().equals(modelName)) { for (SNode _n : d.getRootNodes()) { SNode n = (SNode) _n; if (SNodeOperations.isInstanceOf(n, "jetbrains.mps.baseLanguage.structure.Classifier") && SPropertyOperations.getString( SNodeOperations.cast(n, "jetbrains.mps.baseLanguage.structure.Classifier"), "name") .equals(rootName)) { return true; } } } } return false; }
public synchronized Set<SModelReference> resolveModel( SModule module, String name, @Nullable SNodeId nodeId) { Pair<SModuleReference, String> key = new Pair<SModuleReference, String>(module.getModuleReference(), name); ensureInitialized(key); Set<SModelReference> models = myStubModulesCache.get(key); if (nodeId == null) return new HashSet<SModelReference>(models); Set<SModelReference> result = new HashSet<SModelReference>(); for (SModelReference ref : models) { SModel m = SModelRepository.getInstance().getModelDescriptor(ref); if (m.getNode(nodeId) != null) { result.add(ref); } } return result; }
public void updateDeps(SModule mod) { SModuleReference mr = mod.getModuleReference(); ModulesCluster.ModuleDeps deps = MapSequence.fromMap(allDeps).get(mr); if (deps == null) { deps = new ModulesCluster.ModuleDeps(mr); MapSequence.fromMap(allDeps).put(mr, deps); } ListSequence.fromList(deps.required).addSequence(Sequence.fromIterable(required(mod))); for (SModuleReference req : deps.required) { if (MapSequence.fromMap(allDeps).containsKey(req)) { ListSequence.fromList(MapSequence.fromMap(allDeps).get(req).dependent).addElement(mr); } } for (IMapping<SModuleReference, ModulesCluster.ModuleDeps> m : MapSequence.fromMap(allDeps).mappingsSet()) { if (ListSequence.fromList(m.value().required).contains(mr) && !(ListSequence.fromList(deps.dependent).contains(m.key()))) { ListSequence.fromList(deps.dependent).addElement(m.key()); } } }
/** Build set of dependencies for the given module, grouped under a fake root container */ public DepLink build(SModule module) { DepLink rv = new DepLink(module.getModuleReference(), DependencyUtil.Role.None, null); List<DepLink> queue = ListSequence.fromList(new LinkedList<DepLink>()); ListSequence.fromList(queue).addElement(rv); Map<Dependency, DepLink> visited = MapSequence.fromMap(new HashMap<Dependency, DepLink>()); while (ListSequence.fromList(queue).isNotEmpty()) { DepLink e = ListSequence.fromList(queue).removeElementAt(0); List<DepLink> dependencies = dependencies(e.role, e.module); for (DepLink d : ListSequence.fromList(dependencies)) { d.myParent = e; ListSequence.fromList(e.children()).addElement(d); Dependency key = d.getRoleModuleKey(); if (MapSequence.fromMap(visited).containsKey(key)) { d.setReused(MapSequence.fromMap(visited).get(key)); } else { MapSequence.fromMap(visited).put(key, d); ListSequence.fromList(queue).addElement(d); } } } return rv; }
/** * FIXME Obviously it must be internal module method: it must be done on the fs update (actually * it is #update method here) Nobody must recount the module dependency versions from the outside * AP * * <p>Currently happens only during migration; * * @deprecated please do not use */ @Deprecated @ToRemove(version = 3.4) public void validateDependencyVersions() { assertCanChange(); ModuleDescriptor md = getModuleDescriptor(); if (md == null) { return; } Map<SModuleReference, Integer> oldDepVersions = md.getDependencyVersions(); Map<SModuleReference, Integer> newDepVersions = new HashMap<SModuleReference, Integer>(); Set<SModule> visible = new LinkedHashSet<SModule>(); visible.add(this); PostingWarningsErrorHandler handler = new PostingWarningsErrorHandler(); Collection<SModule> dependentModules = new GlobalModuleDependenciesManager(this, handler).getModules(Deptype.VISIBLE); if (handler.hasErrors()) { return; } visible.addAll(dependentModules); if (!md.hasDependencyVersions()) { for (SModule dep : visible) { newDepVersions.put(dep.getModuleReference(), 0); } md.setHasDependencyVersions(true); } else { for (SModule dep : visible) { if (oldDepVersions.containsKey(dep.getModuleReference())) { newDepVersions.put( dep.getModuleReference(), oldDepVersions.get(dep.getModuleReference())); } else { newDepVersions.put(dep.getModuleReference(), ((AbstractModule) dep).getModuleVersion()); setChanged(); } } if (oldDepVersions.size() != newDepVersions.size()) { setChanged(); } } oldDepVersions.clear(); oldDepVersions.putAll(newDepVersions); }
@Override public Set<SLanguage> getUsedLanguages() { return myPeer.getUsedLanguages(); }
private boolean isExcluded(@NotNull SModule m) { return m.isReadOnly() || !SModuleOperations.isCompileInMps(m); }
@Override protected void executeTask(Project project, MpsWorker.ObjectsToProcess go) { Set<SModule> toCompile = SetSequence.fromSet(new LinkedHashSet<SModule>()); SetSequence.fromSet(toCompile).addSequence(SetSequence.fromSet(go.getModules())); for (Project p : go.getProjects()) { SetSequence.fromSet(toCompile).addSequence(SetSequence.fromSet(go.getModules())); } for (final SModel modelDescriptor : go.getModels()) { SModule owningModule = ModelAccess.instance() .runReadAction( new Computable<SModule>() { public SModule compute() { return modelDescriptor.getModule(); } }); SetSequence.fromSet(toCompile).addElement(owningModule); } final Set<SModule> finalToCompile = CollectionUtil.filter( toCompile, new Condition<SModule>() { public boolean met(SModule module) { boolean compileInMps = !(module instanceof IModule) || ((IModule) module).isCompileInMPS(); return compileInMps && !(module.isPackaged()); } }); if (finalToCompile.isEmpty()) { return; } info("Starting compilation:"); StringBuffer sb = new StringBuffer(); for (SModule m : finalToCompile) { sb.append(" "); sb.append(m.getModuleName()); sb.append("\n"); } info(sb.toString()); MPSCompilationResult result = ModelAccess.instance() .runReadAction( new Computable<MPSCompilationResult>() { public MPSCompilationResult compute() { return new ModuleMaker() .make( finalToCompile, new EmptyProgressMonitor() { @Override public void step(String text) { info(" " + text); } @Override public void start(String taskName, int work) { info(taskName); } }); } }); info(result.toString()); }
private MPSCompilationResult compile(Set<SModule> modules, JavaCompilerOptions compilerOptions) { boolean hasAnythingToCompile = false; List<IMessage> messages = new ArrayList<IMessage>(); for (SModule m : modules) { if (isExcluded(m)) continue; hasAnythingToCompile = true; } if (!hasAnythingToCompile) { return new MPSCompilationResult(0, 0, false, Collections.<SModule>emptySet()); } JavaCompiler compiler = new JavaCompiler(); boolean hasJavaToCompile = false; boolean hasFilesToCopyOrDelete = false; myTracer.push("preparing to compile", false); Set<SModule> modulesWithRemovals = new HashSet<SModule>(); for (SModule m : modules) { if (areClassesUpToDate(m)) continue; if (!getJavaFacet(m).isCompileInMps()) { String text = "Module which compiled in IDEA depends on module which has to be compiled in MPS:" + m.getModuleName(); messages.add(createMessage(MessageKind.WARNING, text, m)); myHandler.handle(createMessage(MessageKind.INFORMATION, text, m)); continue; } ModuleSources sources = getModuleSources(m); hasFilesToCopyOrDelete |= !sources.isResourcesUpToDate(); hasJavaToCompile |= !sources.isJavaUpToDate(); for (File f : sources.getFilesToDelete()) { //noinspection ResultOfMethodCallIgnored f.delete(); modulesWithRemovals.add(m); } for (JavaFile f : sources.getFilesToCompile()) { compiler.addSource(f.getClassName(), f.getContents()); myContainingModules.put(f.getClassName(), m); } } myTracer.pop(); if (!hasJavaToCompile && !hasFilesToCopyOrDelete) { return new MPSCompilationResult(0, 0, false, Collections.<SModule>emptySet(), messages); } myTracer.push("invalidating classpath", false); for (SModule module : modulesWithRemovals) { invalidateCompiledClasses(module); } myTracer.pop(); Set<SModule> changedModules = new HashSet<SModule>(); MyCompilationResultAdapter listener = null; if (hasJavaToCompile) { myTracer.push("compiling java", false); IClassPathItem classPathItems = computeDependenciesClassPath(modules); listener = new MyCompilationResultAdapter(modules, classPathItems, messages); compiler.addCompilationResultListener(listener); myTracer.push("eclipse compiler", true); if (compilerOptions == null) { compiler.compile(classPathItems); } else { compiler.compile(classPathItems, compilerOptions); } myTracer.pop(); changedModules.addAll(listener.myChangedModules); compiler.removeCompilationResultListener(listener); myTracer.pop(); } myTracer.push("copying resources", false); for (SModule module : modules) { ModuleSources sources = getModuleSources(module); IFile classesGen = getJavaFacet(module).getClassesGen(); if (classesGen == null) { continue; } for (ResourceFile toCopy : sources.getResourcesToCopy()) { String fqName = toCopy.getPath(); fqName = fqName.substring(0, fqName.length() - toCopy.getFile().getName().length()); String path = fqName.replace('/', File.separatorChar) + toCopy.getFile().getName(); if (new File(toCopy.getFile().getAbsolutePath()).exists()) { FileUtil.copyFile( new File(toCopy.getFile().getAbsolutePath()), new File(classesGen.getDescendant(path).getPath())); } } } myTracer.pop(); myTracer.push("updating classpath", false); for (SModule module : changedModules) { invalidateCompiledClasses(module); } myTracer.pop(); for (SModule module : modulesWithRemovals) { if (!changedModules.contains(module)) { myHandler.handle( createMessage( MessageKind.WARNING, "Module with removals not in changed modules: " + module, module)); } } // todo: check possibility of this statements if (hasJavaToCompile && changedModules.isEmpty()) { myHandler.handle( createMessage( MessageKind.ERROR, "has java to compile but changed modules is empty", null)); } if (!hasJavaToCompile && !changedModules.isEmpty()) { myHandler.handle( createMessage( MessageKind.ERROR, "has not java to compile but changed modules is not empty", null)); } return new MPSCompilationResult( listener == null ? 0 : listener.getErrorCount(), 0, false, changedModules, messages); }
@Override public Iterable<SDependency> getDeclaredDependencies() { return myPeer.getDeclaredDependencies(); }
public String getMatchingText_internal(SModule parameterObject) { return parameterObject.getModuleName(); }
public static SModuleReference createReference(String moduleName) { // TODO use SRepository? SModuleReference ref = new ModuleReference(moduleName); SModule module = getInstance().getModule(ref); return module != null ? module.getModuleReference() : ref; }
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 void applyRule( final SNode buildSolutionRunner, final TypeCheckingContext typeCheckingContext, IsApplicableStatus status) { final String className = BehaviorReflection.invokeVirtual( String.class, buildSolutionRunner, "virtual_getClassName_1350734474210951475", new Object[] {}); final String methodName = BehaviorReflection.invokeVirtual( String.class, buildSolutionRunner, "virtual_getMethodName_1350734474210955274", new Object[] {}); SModuleReference moduleReference = ModuleReference.parseReference( BuildMps_AbstractModule_Behavior.call_getModuleReference_4643216374596368935( SLinkOperations.getTarget( buildSolutionRunner, MetaAdapterFactory.getReferenceLink( 0x427a473d5177432cL, 0x9905bcbceb71b996L, 0x39ea87a41cc0827eL, 0x54b085b5945c6691L, "solution")))); SModule module = GlobalScope.getInstance().resolve(moduleReference); if (module != null) { for (SModel m : module.getModels()) { if (SModelOperations.getModelName(m).equals(module.getModuleName())) { SNode classToRun = ListSequence.fromList( SModelOperations.roots( m, MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8c108ca66L, "jetbrains.mps.baseLanguage.structure.ClassConcept"))) .findFirst( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return SPropertyOperations.getString( it, MetaAdapterFactory.getProperty( 0xceab519525ea4f22L, 0x9b92103b95ca8c0cL, 0x110396eaaa4L, 0x110396ec041L, "name")) .equals(className); } }); if ((classToRun == null)) { continue; } SNode methodToRun = Sequence.fromIterable( ClassConcept_Behavior.call_staticMethods_5292274854859435867(classToRun)) .findFirst( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return SPropertyOperations.getString( it, MetaAdapterFactory.getProperty( 0xceab519525ea4f22L, 0x9b92103b95ca8c0cL, 0x110396eaaa4L, 0x110396ec041L, "name")) .equals(methodName) && SNodeOperations.isInstanceOf( SLinkOperations.getTarget( it, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x112670d273fL, 0x112670d886aL, "visibility")), MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x10af9581ff1L, "jetbrains.mps.baseLanguage.structure.PublicVisibility")) && ListSequence.fromList( SLinkOperations.getChildren( it, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b1fcL, 0xf8cc56b1feL, "parameter"))) .isEmpty(); } }); if ((methodToRun != null)) { return; } } } } { MessageTarget errorTarget = new NodeMessageTarget(); errorTarget = new ReferenceMessageTarget("solution"); IErrorReporter _reporter_2309309498 = typeCheckingContext.reportTypeError( buildSolutionRunner, "Cannot find public static void " + className + "." + methodName + "() in " + SPropertyOperations.getString( SLinkOperations.getTarget( buildSolutionRunner, MetaAdapterFactory.getReferenceLink( 0x427a473d5177432cL, 0x9905bcbceb71b996L, 0x39ea87a41cc0827eL, 0x54b085b5945c6691L, "solution")), MetaAdapterFactory.getProperty( 0xceab519525ea4f22L, 0x9b92103b95ca8c0cL, 0x110396eaaa4L, 0x110396ec041L, "name")), "r:6869e2b7-2b2d-443c-a462-ce5a9004892e(jetbrains.mps.build.mps.runner.typesystem)", "7415565752189086936", null, errorTarget); } }
/** * Note: here we are interested in the actual status of module. (not {@link * ReferenceStorage#resolveRef}) if it has been already disposed but still remains in our graphs * (i.e. ClassLoader is not disposed yet [!]), we need to mark it invalid */ private boolean isModuleDisposed(SModuleReference mRef) { SModule resolvedModule = mRef.resolve(myRepository); return (resolvedModule == null || resolvedModule.getRepository() == null); }
public void applyRule( final SNode classifier, final TypeCheckingContext typeCheckingContext, IsApplicableStatus status) { if (SNodeOperations.isInstanceOf( classifier, MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x1107e0cb103L, "jetbrains.mps.baseLanguage.structure.AnonymousClass")) || SNodeOperations.isInstanceOf( classifier, MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xfc367070a5L, "jetbrains.mps.baseLanguage.structure.EnumClass"))) { return; } if (SNodeOperations.isInstanceOf( SLinkOperations.getTarget( classifier, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x112670d273fL, 0x112670d886aL, "visibility")), MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x10af9586f0cL, "jetbrains.mps.baseLanguage.structure.PrivateVisibility"))) { return; } SModule module = classifier.getModel().getModule(); GlobalModuleDependenciesManager depManager = new GlobalModuleDependenciesManager(module); Collection<SModule> deps = depManager.getModules(GlobalModuleDependenciesManager.Deptype.COMPILE); Collection<SModule> depsReexport = depManager.getOnlyReexportModules(); for (SNode extendedClassifierType : Classifier__BehaviorDescriptor.getExtendedClassifierTypes_id1UeCwxlWKny.invoke( classifier)) { SNode extendedClassifier = SLinkOperations.getTarget( extendedClassifierType, MetaAdapterFactory.getReferenceLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x101de48bf9eL, 0x101de490babL, "classifier")); if (extendedClassifier == SNodeOperations.getNode( "6354ebe7-c22a-4a0f-ac54-50b52ab9b065/java:java.lang(JDK/)", "~Object")) { continue; } SModule classifierModule = extendedClassifier.getModel().getModule(); assert classifierModule != null; if (deps.contains(classifierModule) && !(depsReexport.contains(classifierModule))) { { MessageTarget errorTarget = new NodeMessageTarget(); IErrorReporter _reporter_2309309498 = typeCheckingContext.reportWarning( classifier, "Usages of this classifier outside of '" + module.getModuleName() + "' module requires setting 'Export' flag for the dependency on '" + classifierModule.getModuleName() + "' module", "r:00000000-0000-4000-0000-011c895902c5(jetbrains.mps.baseLanguage.typesystem)", "9721774220123915", null, errorTarget); { BaseQuickFixProvider intentionProvider = new BaseQuickFixProvider( "jetbrains.mps.baseLanguage.typesystem.PutReexportForExtendedClassifier_QuickFix", false); intentionProvider.putArgument("module", ((AbstractModule) module)); intentionProvider.putArgument("moduleToImport", classifierModule); _reporter_2309309498.addIntentionProvider(intentionProvider); } } } } }
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; }