@Override public Iterable<SDependency> getDeclaredDependencies() { assertCanRead(); ModuleDescriptor descriptor = getModuleDescriptor(); if (descriptor == null) { return Collections.emptyList(); } HashSet<SDependency> result = new HashSet<SDependency>(); final SRepository repo = getRepository(); if (repo == null) { throw new IllegalStateException( "It is not possible to resolve all declared dependencies with a null repository : module " + this); } // add declared dependencies for (Dependency d : descriptor.getDependencies()) { result.add(new SDependencyImpl(d.getModuleRef(), repo, d.getScope(), d.isReexport())); } // add dependencies provided by devkits as nonreexport dependencies for (SModuleReference usedDevkit : descriptor.getUsedDevkits()) { final SModule devkit = usedDevkit.resolve(repo); if (DevKit.class.isInstance(devkit)) { for (Solution solution : ((DevKit) devkit).getAllExportedSolutions()) { result.add( new SDependencyImpl( solution.getModuleReference(), repo, SDependencyScope.DEFAULT, false)); } } } return result; }
// fills collections with of imported languages and devkits. // Languages include directly imported and coming immediately through devkits; listed devkits are // imported directly, without those they extend (why?). public LangAndDevkits collectLanguagesAndDevkits() { Set<SLanguage> usedLanguages = new LinkedHashSet<>(); Set<SModuleReference> devkits = new LinkedHashSet<>(); // perhaps, shall introduce ModuleImports similar to ModelImports to accomplish this? for (SModel m : getModels()) { final SModelInternal modelInternal = (SModelInternal) m; usedLanguages.addAll(modelInternal.importedLanguageIds()); devkits.addAll(modelInternal.importedDevkits()); } // XXX why don't we respect extended devkits here? final SRepository repository = getRepository(); if (repository != null) { for (SModuleReference devkitRef : devkits) { final SModule module = devkitRef.resolve(repository); if (module instanceof DevKit) { for (SLanguage l : ((DevKit) module).getAllExportedLanguageIds()) { usedLanguages.add(l); } } } } usedLanguages.add(BootstrapLanguages.getLangCore()); return new LangAndDevkits(usedLanguages, devkits); }
/** @return message with the problem description or null if the module is valid */ @Nullable @Hack private String getModuleProblemMessage( SModuleReference mRef, Map<ReloadableModule, AbsentDependencyException> modulesWithAbsentDeps) { assert !isChanged(); if (isModuleDisposed(mRef)) { return String.format( "Module %s is disposed and therefore was marked invalid for class loading", mRef.getModuleName()); } ReloadableModule module = (ReloadableModule) mRef.resolve(myRepository); assert module != null; // FIXME does not work for now, enable in the 3.4 if (modulesWithAbsentDeps.containsKey(module)) { AbsentDependencyException exception = modulesWithAbsentDeps.get(module); return String.format( "%s has got an absent dependency problem and therefore was marked invalid for class loading: %s", module, exception.getMessage()); } for (SDependency dep : module.getDeclaredDependencies()) { if (dep.getScope() == SDependencyScope.DESIGN || dep.getScope() == SDependencyScope.GENERATES_INTO) { continue; } if (isModuleDisposed(dep.getTargetModule())) { return String.format( "%s depends on a disposed module %s and therefore was marked invalid for class loading", module, dep.getTargetModule()); } } return null; }
/*package*/ void updateIcon(SRepository repo) { SModule m = myModule.resolve(repo); if (m == null) { setIcon(IdeIcons.DEFAULT_ICON); } else { setIcon(IconManager.getIconFor(m)); } }
@Override public Dependency addDependency(@NotNull SModuleReference moduleRef, boolean reexport) { // we do not add a dependency into solution, we add dependency to idea module instead ModifiableRootModel modifiableModel = ModuleRootManager.getInstance(myModule).getModifiableModel(); SModule sModule = moduleRef.resolve(MPSModuleRepository.getInstance()); // FIXME module repo if (sModule instanceof SolutionIdea) { // we add dependency between idea modules Module otherIdeaModule = ((SolutionIdea) sModule).getIdeaModule(); modifiableModel.addModuleOrderEntry(otherIdeaModule); } else { ModuleRuntimeLibrariesImporter.importForUsedModules( myModule, Collections.singleton(moduleRef), modifiableModel); } modifiableModel.commit(); return null; }
/** * 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); }
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; }