Deprecated API

Contents

• Interfaces
• Classes
• Enums
• Exceptions
• Fields
• Methods
• Constructors

Interfaces

Interface	Description
jetbrains.mps.extapi.model.SModelPersistence	Consider using CustomPersistenceLoadFacility instead evgeny, 3/22/13
jetbrains.mps.ide.findusages.findalgorithm.finders.IFinder
jetbrains.mps.make.script.IProgress	Of no use any longer, scheduled for removal.
jetbrains.mps.smodel.IOperationContext	It appears that we always have a project and a module instances in the scope, where IOperationContext is being used. So in this case we should pass a project itself instead of passing an IOperationContext instance. The same needs to be done with a module. isValid and isTestMode are helping methods, which should be implemented in place. getComponent method should be replaced by Project method getComponent for now. Later it needs to be replaced with a corresponding static method call getInstance of the component class {T}.
jetbrains.mps.smodel.legacy.ConceptMetaInfoConverter	this is transition code, don't use unless for intended purpose
jetbrains.mps.smodel.resources.ICResouce
jetbrains.mps.smodel.resources.IDeltaResource
jetbrains.mps.smodel.resources.IGResource
jetbrains.mps.smodel.resources.IMResource
jetbrains.mps.smodel.resources.ITResource
jetbrains.mps.smodel.runtime.BehaviorDescriptor
jetbrains.mps.tool.common.IMessageFormat	in MPS, there are no more uses of this interface nor uses of subclasses. Unless anybody needs this one, shall cease to exist.
jetbrains.mps.util.Callback
jetbrains.mps.util.MacroHelper
jetbrains.mps.vfs.FileSystem
jetbrains.mps.vfs.openapi.FileSystem
jetbrains.mps.vfs.path.Path
jetbrains.mps.vfs.refresh.FileSystemListener	use FileListener in the case when you do not need to have any dependencies. Otherwise carry on with this one.
org.jetbrains.mps.openapi.language.SPrimitiveDataType	Use one of SPrimitiveTypes
org.jetbrains.mps.openapi.model.SModelScope
org.jetbrains.mps.openapi.module.RepositoryAccess

Classes

Class	Description
jetbrains.mps.analyzers.runtime.framework.DataFlowConstructor	use jetbrains.mps.lang.dataFlow.framework.DataFlowConstructor
jetbrains.mps.build.ant.AllModulesDataType
jetbrains.mps.build.ant.CustomMPSLoadTask	MpsLoadTask could do the same
jetbrains.mps.build.ant.ModuleJarDataType	use instead
jetbrains.mps.errors.NullErrorReporter
jetbrains.mps.extapi.model.CustomPersistenceSModel	better use CustomPersistenceModelWithHeader
jetbrains.mps.extapi.persistence.FolderModelRootBase	use FileBasedModelRoot instead There are few instanceof checks with this class in MPS, but no subclasses for quite some time now. The class will be removed once corresponding code is wiped out and 2018.3 is out evgeny, 11/9/12
jetbrains.mps.generator.fileGenerator.FileGenerationUtil	This class doesn't respect overridden output location (GeneratableSModel.isGenerateIntoModelFolder() nor does it tell anything about where to take outputRootDir from (assumes it comes from jetbrains.mps.project.SModuleOperations#getOutputRoot(SModel) while it's common to see invocations of FileGenerationUtil.getDefaultOutputDir(SModel, IFile) with ((AbstractModule) module).getOutputPath() TODO remove once 3.5 is out as replacement API, GenerationTargetFacet, has been introduced in 3.5 and there's no legitimate way to get rid of used of the class prior to that. Uses of the class in MPS code are implementation dependencies and shall get refactored one the class is gone (either copy implementation or drop transitional uses).
jetbrains.mps.InternalFlag	use RuntimeFlags
jetbrains.mps.kernel.model.SModelUtil	use S-entities instead
jetbrains.mps.lang.smodel.generator.smodelAdapter.SLinkOperations
jetbrains.mps.make.IMakeService.INSTANCE	global singleton is not a proper way to obtain active make facility of MPS platform. Instead, use MakeServiceComponent.
jetbrains.mps.make.script.IProgress.Stub	Do not use
jetbrains.mps.project.MementoWithFS	model root factory will pass module to the constructor of any model root
jetbrains.mps.project.ModuleContext	shall cease along with IOperationContext
jetbrains.mps.project.ProjectOperationContext	see IOperationContext
jetbrains.mps.project.structure.ProjectStructureModule	there seems to be no justification for stateless PSM. Tell MPS team (Artem) if you got any. Otherwise, the code will cease to exist soon.
jetbrains.mps.refactoring.framework.RefactoringUtil	Use RefactoringAccess instead
jetbrains.mps.reloading.ReflectionUtil	Deprecated along with bl.Expression.eval() which seems to be only client of this code. Drop it once eval() is gone.
jetbrains.mps.smodel.adapter.structure.concept.SDataTypeAdapter	Use another SDataType instance (e.g SPrimitiveTypes.STRING or {@link InvalidDataType)})
jetbrains.mps.smodel.adapter.structure.concept.SPrimitiveDataTypeAdapter	Use one of SPrimitiveTypes
jetbrains.mps.smodel.adapter.structure.MetaAdapterFactoryByName
jetbrains.mps.smodel.adapter.structure.SEnumAdapter	Do not use it!!! This class do not implement its contract! Use SEnumerationAdapter that delegates to generated descriptors
jetbrains.mps.smodel.adapter.structure.types.SInterpretedConstrainedStringDataTypeAdapter	Use SConstrainedStringDatatypeAdapter
jetbrains.mps.smodel.adapter.structure.types.SInterpretedEnumerationAdapter	Use SEnumerationAdapter
jetbrains.mps.smodel.BootstrapLanguages
jetbrains.mps.smodel.ModuleFileTracker	It's possible to have more than one module for the same file (e.g. .mpl hosts both language and its generators). Review uses of the class and decide whether its API needs an update or we don't need it altogether (there are few dubious uses, it's not evident if there's any value in this map). For the time being, whatever module it gives, is fine. Destiny of the class seems to be as follows: uses in ShowInLogicalView are replaced with SelectInContext/SelectInTarget and therefore reduced to ProjectPaneSelectInTarget, which is initialized from MPSProject and (a) has access to project descriptor with module files; (b) may keep its own cache of project modules/files or build one on demand each time as needed (for specific project repository). Then, there'd be no need to have this general component. There's also 1 use in mbeddr (mpsutil.projectview.runtime), shall reuse SelectInTarget or just walk repository modules There are no uses in MPS, one in mbeddr, though
jetbrains.mps.smodel.Primitives	Use jetbrains.mps.smodel.adapter.structure.types.SPrimitiveTypes instead
jetbrains.mps.smodel.PropertySupport	Use datatype API
jetbrains.mps.smodel.PropertySupport.PropertySupportCache
jetbrains.mps.smodel.search.SModelSearchUtil
jetbrains.mps.smodel.SNodeLegacy	marked as deprecated to clearly indicate code needs re-write
jetbrains.mps.tool.builder.make.ConsoleMessageFormat	see IMessageFormat for reasons
jetbrains.mps.tool.common.TeamCityMessageFormat	see IMessageFormat for reasons
jetbrains.mps.util.CopyFacetUtil	the class has been superseded by @CopyOutput annotation of jetbrains.mps.lang.makeup language. User: shatalin Date: 08/12/15
jetbrains.mps.util.Icon2IconResourceAdapter_Deprecated	this class is for compatibility purposes and must not be used except internally. It will be removed after 3.4
jetbrains.mps.util.URLUtil
jetbrains.mps.vfs.Files
jetbrains.mps.vfs.FileSystemExtPoint
jetbrains.mps.vfs.FileSystems
jetbrains.mps.vfs.impl.IoFileSystem

Enums

Enum	Description
org.jetbrains.mps.openapi.persistence.NotImplementedModelFactoryType	Temporary stub implementation for users to migrate on the new API

Exceptions

Exceptions	Description
jetbrains.mps.classloading.ModuleIsNotLoadableException	It has been to decided to get rid of additional classnotfoundexceptions

Fields

Field	Description
jetbrains.mps.extapi.model.GeneratableSModel.FILE	of no use for MPS
jetbrains.mps.extapi.model.GeneratableSModel.HEADER	of no use for MPS
jetbrains.mps.extapi.persistence.FileBasedModelRoot.EXCLUDED	use SourceRootKinds.EXCLUDED instead
jetbrains.mps.extapi.persistence.FileBasedModelRoot.SOURCE_ROOTS	use SourceRootKinds.SOURCES instead
jetbrains.mps.project.MPSExtentions.RUNTIME_ARCH
jetbrains.mps.smodel.Language.LEGACY_LANGUAGE_MODELS	Use of default value to detect aspect source root or to check module existence is wrong.
jetbrains.mps.smodel.StringBasedIdForJavaStubMethods.ID_PREFIX

Methods

Method	Description
jetbrains.mps.build.ant.MPSClasspathUtil.buildClasspath(Project, File, boolean)	there are no uses I'm aware of, nevertheless, gonna keep for another release (to be removed once 2019.1 is out)
jetbrains.mps.build.ant.MPSClasspathUtil.gatherAllClassesAndJarsUnder(File, Set<File>)	about to reduce visibility to package or to become an instance method of an mps classpath utility class
jetbrains.mps.build.ant.MPSClasspathUtil.resolveMPSHome(Project, boolean)	shall become instance method of an mps classpath utility class
jetbrains.mps.build.ant.MpsLoadTask.getWorkerClass()	pass worker class name as cons argument or using #setWorker
jetbrains.mps.build.ant.RepositoryDataType.addConfiguredAllMpsModules(AllModulesDataType)
jetbrains.mps.classloading.ClassLoaderManager.getClass(SModule, String)	use module-specific methods which throw different ClassNotFoundExceptions, you need to process it on your own (probably show some user notification)
jetbrains.mps.classloading.ClassLoaderManager.getInstance()	use ComponentHost#findComponent(ClassLoaderManager.class) instead
jetbrains.mps.classloading.ClassLoaderManager.getOwnClass(SModule, String)	use module-specific methods which throw different ClassNotFoundExceptions, you need to process it by yourself (probably show some user notification)
jetbrains.mps.classloading.ClassLoaderManager.reloadAll(ProgressMonitor)
jetbrains.mps.classloading.ClassLoaderManager.runNonReloadableTransaction(Runnable)
jetbrains.mps.compiler.EclipseJavaCompiler.getClassLoader(ClassLoader)
jetbrains.mps.extapi.model.GeneratableSModel.getGenerationHashes()	bogus, finally unused api rootId => root hash HEADER => header hash FILE => model hash
jetbrains.mps.extapi.model.PersistenceProblem.fromIMessage(SModelData, SModel.Problem.Kind, IMessage)	not in use, is it worth to keep?
jetbrains.mps.extapi.model.SModelBase.getModelName()
jetbrains.mps.extapi.model.SModelData.getReference()	Generally, SModelReference may get complete only at the moment model is attached to a module (there's SModelReference.getModuleReference() and we can't assume SModelData is only for UUID models), therefore it's odd to expect SModelReference for an SModelData.
jetbrains.mps.extapi.model.SModelDescriptorStub.fireBeforeModelRenamed(SModelRenamedEvent)
jetbrains.mps.extapi.model.SModelDescriptorStub.fireModelRenamed(SModelRenamedEvent)
jetbrains.mps.extapi.model.SModelDescriptorStub.fireModelStateChanged(ModelLoadingState)	(a) we are in process to get rid of SModelListener; (b) this method used to change loading state in addition to event dispatch, and if you used to invoke it, please re-consider that code.
jetbrains.mps.extapi.model.SModelDescriptorStub.getModelDepsManager()	There's no reason to cast openapi.SModel to SModelDescriptorStub to get ModelDependenciesManager instance as it's no longer cached and provides no extra benefit compared to direct new ModelDependenciesManager(model). Besides, use of ModelDependenciesManager is discouraged and ModelDependencyResolver shall be preferred.
jetbrains.mps.extapi.model.SModelDescriptorStub.getSModelInternal()	use SModelBase.getModelData() or SModelDescriptorStub.getSModel() FIXME there's implicit convention that smodel.SModel has this openapi.SModel (aka descriptor) assigned once this method returns
jetbrains.mps.extapi.module.SRepositoryRegistry.getInstance()	Instead, access instance through respective kernel ComponentPlugin (i.e. MPSCore). There are no uses in MPS, although there are still few in mbeddr
jetbrains.mps.extapi.persistence.datasource.DataSourceFactoryRuleService.getInstance()	Use MPS standard mechanism to access component instances
jetbrains.mps.extapi.persistence.FileBasedModelRoot.addFile(String, String)	use FileBasedModelRoot.addSourceRoot(SourceRootKind, SourceRoot) instead
jetbrains.mps.extapi.persistence.FileBasedModelRoot.containsFile(String, String)	use FileBasedModelRoot.getSourceRoots(SourceRootKind) + List.contains(java.lang.Object).
jetbrains.mps.extapi.persistence.FileBasedModelRoot.deleteFile(String, String)	use FileBasedModelRoot.removeSourceRoot(SourceRoot) instead
jetbrains.mps.extapi.persistence.FileBasedModelRoot.getContentRoot()	use FileBasedModelRoot.getContentDirectory() instead
jetbrains.mps.extapi.persistence.FileBasedModelRoot.getFiles(String)	use FileBasedModelRoot.getSourceRoots(SourceRootKind) instead
jetbrains.mps.extapi.persistence.FileBasedModelRoot.getSupportedFileKinds()	String is not the best choice. Consider using FileBasedModelRoot.getSupportedFileKinds1()
jetbrains.mps.extapi.persistence.FileBasedModelRoot.setContentRoot(String)	use FileBasedModelRoot.setContentDirectory(IFile) instead
jetbrains.mps.extapi.persistence.ModelFactoryService.getInstance()	access through ComponentHost.findComponent(Class)
jetbrains.mps.findUsages.FindUsagesManager.getInstance()	it's CoreComponent, use ComponentHost.findComponent(Class) to retrieve an instance
jetbrains.mps.findUsages.SearchType.search(Set<R>, SearchScope, ProgressMonitor)	a client should migrate to the SearchType.search(Set, SearchScope, Consumer, ProgressMonitor) instead
jetbrains.mps.generator.GenerationParametersProviderEx.getAdditionalLanguages(SModel)	use generation plans to control which languages and generators are involved. String for a language is not a best possible API anyway.
jetbrains.mps.generator.GenerationPlanBuilder.applyGenerator(SModule...)	use GenerationPlanBuilder.applyGenerators(Collection, BuilderOption...) instead
jetbrains.mps.generator.GenerationSessionContext.getRepository()	Transitional access to SRepository. Likely, the code that needs a repository shall get refactored not to use one. Contract is questionable, provided we head towards distinct repository for transient models. For the time being, this repository corresponds to generator's environment, e.g. project it's run from.
jetbrains.mps.generator.GenerationSettingsProvider.getInstance()	it's a CoreComponent, use ComponentHost.findComponent(Class) to access proper instance
jetbrains.mps.generator.impl.GenControllerContext.getRepository()	see GenerationSessionContext.getRepository() for reasons. It's not the idea that generator knows about the context repository is bad, we just need better story around it.
jetbrains.mps.generator.impl.RuleUtil.getTemplateDeclarationReference_Template(SNode)	use getTemplateCall_Template instead
jetbrains.mps.generator.impl.RuleUtil.getWeaveEach_Template(SNode)
jetbrains.mps.generator.ModelGenerationStatusListener.generatedFilesChanged(SModel)	override ModelGenerationStatusListener.generatedFilesChanged(Collection) instead
jetbrains.mps.generator.ModelGenerationStatusManager.getInstance()
jetbrains.mps.generator.runtime.NodeWeaveFacility.weaveTemplate(SNodeReference, Object...)	use TemplateExecutionEnvironment.findTemplate(TemplateDeclarationKey, SNodeReference) and subsequent TemplateDeclarationWeavingAware2.weave(WeaveContext, NodeWeaveFacility) instead
jetbrains.mps.generator.runtime.TemplateExecutionEnvironment.applyTemplate(SNodeReference, SNodeReference, TemplateContext, Object...)	This method implies instances of TemplateDeclaration rt class are per-invocation (well, technically, one could implement this method in a way to keep cache of TD instances and to configure them with arguments on each apply, it's just more natural to keep TD instances in the place we call this applyTemplate from, like TemplateProcessor's CALL/INCLUDE macros). However, it's fine as frontend for generated code and perhaps, shall stay as one, while interpreted code might get alternative facility to access cacheable TD instances. Nevertheless, existing API is bad, templateNode and context are just to report errors, which could be done by caller, if necessary. Besides, mix of Collection and List in API is inconvenient. Has been replaced with TemplateExecutionEnvironment.findTemplate(TemplateDeclarationKey, SNodeReference).
jetbrains.mps.generator.runtime.TemplateModel.loadTemplate(SNodeReference, Object...)	replaced with TemplateModel2.loadTemplate(TemplateDeclarationKey). This method is not generated in new templates, and is overridden in legacy code only, where TemplateModel is not TM2
jetbrains.mps.ide.findusages.findalgorithm.finders.GeneratedFinder.doFind(SNode, SearchScope, List<SNode>, ProgressMonitor)
jetbrains.mps.ide.findusages.findalgorithm.finders.GeneratedFinder.getSearchedNodes(SNode, SearchScope, List<SNode>)
jetbrains.mps.ide.findusages.findalgorithm.finders.SearchedObjects.getElements0()	mutates
jetbrains.mps.ide.findusages.model.SearchResults.add(SearchResult<T>)	use #addSearchResult
jetbrains.mps.ide.findusages.model.SearchResults.addAll(SearchResults<T>)	use #addSearchResults
jetbrains.mps.ide.findusages.model.SearchResults.getSearchedNodes()	need to remove this since it exposes the internals too much. in my view the provided constructors of the class must be enough use #getSearchedObjects instead
jetbrains.mps.ide.findusages.model.SearchResults.getSearchResults()	use #getSearchResults2
jetbrains.mps.ide.findusages.view.FindUtils.executeFinder(String, SNode, SearchScope, ProgressMonitor)
jetbrains.mps.ide.findusages.view.FindUtils.getSearchResults(ProgressMonitor, SNode, SearchScope, String...)
jetbrains.mps.internal.make.runtime.util.StaleFilesCollector.updateDelta(FilesDelta)
jetbrains.mps.kernel.model.SModelUtil.getDirectSuperConcepts(SNode)
jetbrains.mps.lang.dataFlow.framework.Program.insert(Instruction, int, boolean)
jetbrains.mps.lang.migration.runtime.base.MigrationScriptBase.getDescriptor()
jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.asConcept(SNode, SAbstractConcept)
jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.asSConcept(SAbstractConcept)
jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.castConcept(SNode, SAbstractConcept)
jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.getConceptDeclaration(SNode)	used in generator of deprecated concept only
jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.getContainingLinkDeclaration(SNode)
jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.getNode(String, String)	Resolves node in a global repository, avoid
jetbrains.mps.lang.smodel.generator.smodelAdapter.SPropertyOperations.getBoolean_def(SNode, SProperty, String)
jetbrains.mps.lang.smodel.generator.smodelAdapter.SPropertyOperations.getInteger_def(SNode, SProperty, String)
jetbrains.mps.lang.smodel.generator.smodelAdapter.SPropertyOperations.getString_def(SNode, SProperty, String)
jetbrains.mps.lang.smodel.query.runtime.CommandUtil.createConsoleScope(SearchScope, boolean, QueryExecutionContext)
jetbrains.mps.lang.typesystem.runtime.InequationReplacementRule_Runtime.isApplicableSubtype(SNode)
jetbrains.mps.lang.typesystem.runtime.InequationReplacementRule_Runtime.isApplicableSupertype(SNode)
jetbrains.mps.lang.typesystem.runtime.IRuleWithTwoApplicableNodes.isApplicable1(SNode)
jetbrains.mps.lang.typesystem.runtime.IRuleWithTwoApplicableNodes.isApplicable2(SNode)
jetbrains.mps.lang.typesystem.runtime.RuleSet.addRule(T)
jetbrains.mps.languageScope.LanguageScopeFactory.getInstance()
jetbrains.mps.library.LibraryInitializer.getModuleHandles()
jetbrains.mps.library.LibraryInitializer.loadRefreshed(List<LibraryContributor>)	use LibraryInitializer.load(List) instead
jetbrains.mps.library.LibraryInitializer.update()	please use one-step loading methods: LibraryInitializer.loadRefreshed(java.util.List<jetbrains.mps.library.contributor.LibraryContributor>) or LibraryInitializer.load(java.util.List<jetbrains.mps.library.contributor.LibraryContributor>)
jetbrains.mps.logging.MPSAppenderBase.append(Priority, String, String, Throwable, Object)	use with a specified project method instead
jetbrains.mps.make.facet.FacetRegistry.getInstance()	Use ComponentHost#findComponent() instead
jetbrains.mps.make.facet.FacetRegistry.register(IFacet)
jetbrains.mps.make.IMakeService.INSTANCE.get()	the method will be removed after 2018.3 is out
jetbrains.mps.make.java.RootDependencies.getFileName()	this class is about java dependencies, why would I care to keep a file name here?
jetbrains.mps.make.MakeSession.isSticky()	according to Fedor, obsolete functionality. There are usecases when we can benefit from sticky make session and its explicit shutdown, perhaps shall resurrect.
jetbrains.mps.make.script.IScriptController.Stub2.useMonitor(ProgressMonitor)
jetbrains.mps.make.script.IScriptController.useMonitor(ProgressMonitor)
jetbrains.mps.migration.global.BaseProjectMigration.setExecuted(Project)
jetbrains.mps.module.ReloadableModule.getClassLoader()	use ReloadableModule.getClassLoader0()
jetbrains.mps.module.ReloadableModule.willLoad()	bad naming, use #canLoadClasses or sometimes it is more convenient to use getStatus#isDeployed
jetbrains.mps.newTypesystem.state.TargetState.expandTargetNode()
jetbrains.mps.newTypesystem.TypesUtil.match(SNode, SNode, Equations, EquationInfo)
jetbrains.mps.persistence.DefaultModelRoot.toDescriptor()
jetbrains.mps.persistence.PersistenceRegistry.getDefaultModelFactory()
jetbrains.mps.persistence.PersistenceRegistry.getInstance()
jetbrains.mps.persistence.PersistenceRegistry.getModelFactory(String)
jetbrains.mps.project.AbstractModule.getOutputPath()	this is internal method, ask ModuleDescriptor for persisted setting directly, if it's what you're looking for (check ProjectPathUtil.getGeneratorOutputPath(ModuleDescriptor). There ain't no such thing as output path for a module in general. This method is no longer used in MPS, do not resurrect its uses. Although it's not part of openapi, AbstractModule is often deemed as 'almost api', left for one release.
jetbrains.mps.project.AbstractModule.getSourcePaths()	though there are no uses, I still hesitate what's the right way to access source paths of a module ModuleDesciptor.getSourcePath(), actively in use, is the worst possible way, no MD shall get exposed to end-user. SModuleOperations.getAllSourcePaths(this) is better, yet not that discoverable. AbstractModule.getSourcePaths() is both discoverable and not exposing MD, but cast to AM is odd, and getSourcePaths is definitely not a part of SModule API. To me, it's rather part of JavaModuleFacet. Left as a reminder to refactor uses of other APIs prior to removing the method.
jetbrains.mps.project.AbstractModule.getUsedLanguageVersion(SLanguage, boolean)	hack for migration, will be gone after 3.4
jetbrains.mps.project.AbstractModule.updatePackagedDescriptor()	no-op, just drop any usage.
jetbrains.mps.project.dependency.GlobalModuleDependenciesManager.getOnlyReexportModules()	one usage does not justify method's existence
jetbrains.mps.project.dependency.GlobalModuleDependenciesManager.getUsedLanguages()	Use SModule.getUsedLanguages() directly.
jetbrains.mps.project.DevKit.getAllExportedLanguages()	use DevKit.getAllExportedLanguageIds() instead. Once there are no uses, rename getAllExportedLanguageIds to this method and deprecate the former. And, please, stop using Iterable when there's Collection. It's plain stupid to write for() just to add all elements of the iterable to another collection (and don't get me started about IterableUtil.asCollection)
jetbrains.mps.project.FileBasedProject.getProjectFile()	must return IFile todo not so sure now AP
jetbrains.mps.project.GlobalScope.getInstance()	there ain't no such thing as 'global' scope, use GlobalScope(SRepository)
jetbrains.mps.project.io.DescriptorIOFacade.getInstance()	It's CoreComponent, obtain proper instance though platform
jetbrains.mps.project.ModelsAutoImportsManager.AutoImportsContributor.getApplicableSModuleClass()	Use generic ModelsAutoImportsManager.AutoImportsContributor.isApplicable(SModule) instead, and stop parameterising the class with ModuleType, it's to be removed after 2018.3 (signature of all the methods of this class will use SModule then). It's not possible to change ModuleType contextModule to SModule contextModule right away as it breaks compile-time code compatibility.
jetbrains.mps.project.ModelsAutoImportsManager.doAutoImport(SModule, SModel)	use ComponentHost.findComponent(Class) and instance method ModelsAutoImportsManager.performImports(SModule, SModel) instead
jetbrains.mps.project.ModelsAutoImportsManager.getAutoImportedModels(SModule, SModel)	use ComponentHost.findComponent(Class) and instance method ModelsAutoImportsManager.getModelsToImport(SModule, SModel) instead
jetbrains.mps.project.ModelsAutoImportsManager.getDevKits(SModule, SModel)	use ComponentHost.findComponent(Class) and instance method ModelsAutoImportsManager.getDevkitsToImport(SModule, SModel) instead
jetbrains.mps.project.ModelsAutoImportsManager.getLanguages(SModule, SModel)	use ComponentHost.findComponent(Class) and instance method ModelsAutoImportsManager.getLanguagesToImport(SModule, SModel) instead
jetbrains.mps.project.ModelsAutoImportsManager.registerContributor(ModelsAutoImportsManager.AutoImportsContributor)	use ComponentHost.findComponent(Class) and instance method ModelsAutoImportsManager.register(AutoImportsContributor) instead
jetbrains.mps.project.ModelsAutoImportsManager.unregisterContributor(ModelsAutoImportsManager.AutoImportsContributor)	use ComponentHost.findComponent(Class) and instance method ModelsAutoImportsManager.unregister(AutoImportsContributor) instead
jetbrains.mps.project.OptimizeImportsHelper.optimizeModelsImports(List<SModel>)	use OptimizeImportsHelper.optimizeModelsImports(List, ProgressMonitor)
jetbrains.mps.project.OptimizeImportsHelper.optimizeProjectImports(Project)	use OptimizeImportsHelper.optimizeProjectImports(Project, ProgressMonitor) instead
jetbrains.mps.project.PathMacros.getInstance()	it is a CoreComponent, one can get it from MPSPlatform
jetbrains.mps.project.Project.getModules()	use {@link #getProjectModules)} instead AP fixme : why to return Iterable? isn't it easier to give out a collection, e.g. a list?
jetbrains.mps.project.Project.getModulesWithGenerators()	use Project.getProjectModulesWithGenerators() instead
jetbrains.mps.project.Project.getProjectFile()	the project is not necessarily backed up by file. Left for compatibility
jetbrains.mps.project.SModuleOperations.createModelWithAdjustments(String, ModelRoot, ModelFactoryType)	to become private, don't use
jetbrains.mps.project.SModuleOperations.getOutputPathFor(SModel)	use GenerationTargetFacet.getOutputLocation(SModel) or JavaModuleFacet.getOutputRoot(). Even #getOutputRoot(SModel) is much better as it (a) deals with IFile (b) hints it's root, not model-specific location
jetbrains.mps.project.SModuleOperations.getOutputRoots(SModule)	This operation knows about output roots of JavaModuleFacet and TestsFacet only. Locations of any other GenerationTargetFacet are ignored. There's only 1 use in MPS. Client code shall not assume there's single output root for a module, there could be multiple outputs, specified per model.
jetbrains.mps.project.SModuleOperations.reloadFromDisk(AbstractModule)	module provider (library, project, whatever) has to deal with module reload, this helper complicates matters more than resolves any. Once it's gone, AM.loadDescriptor is no longer needed, as well as MM.loadModuleHandle() Reads module from file and eventually redeploys it (when CLManager triggers refresh)
jetbrains.mps.project.structure.modules.ModuleDescriptor.getUsedLanguages()	Now, used languages of a module are derived from models it owns, and thus this list is generally empty. Although generally there might be modules that keep their used languages, and ModuleDescriptor may keep the list, it shall be the list of SLanguage anyway.
jetbrains.mps.project.structure.modules.ModuleDescriptor.hasDependencyVersions()
jetbrains.mps.project.structure.modules.ModuleDescriptor.hasLanguageVersions()
jetbrains.mps.project.structure.modules.ModuleDescriptor.setHasDependencyVersions(boolean)	needed it for migration (3.2->3.3)
jetbrains.mps.project.structure.modules.ModuleDescriptor.setHasLanguageVersions(boolean)	needed it for migration (3.1->3.2)
jetbrains.mps.project.structure.ProjectStructureModule.getInstance()	use ProjectStructureModule.getInstance(SRepository) instead
jetbrains.mps.refactoring.framework.RefactoringContext.getCurrentOperationContext()	fix reduce_OperationContextOperation and delete
jetbrains.mps.refactoring.framework.RefactoringUtil.getApplicability(IRefactoring, Collection)	hasn't been in use from external code, MPS implementation detail. If needed, please request an API method in RefactoringAccess
jetbrains.mps.refactoring.framework.RefactoringUtil.getRefactoringByClassName(String)	use RefactoringAccess.getInstance().getRefactoringByClassName() instead
jetbrains.mps.reloading.ClassBytesProvider.getClass(String)
jetbrains.mps.reloading.IClassPathItem.getAvailableClasses(String)	the only distinction between this method and IClassPathItem.getRootClasses(String) is that this one gives inner classes, but is it something anyone care about? The only use of this method (getAvailableClasses().iterator().hasNext()) would work the same with getRootClasses (inner classes could not be there it there are no outer)
jetbrains.mps.reloading.IClassPathItem.getRootClasses(String)	The only client of this method doesn't seem to be really bound to particular iteration order and could live with API like getAllClasses()
jetbrains.mps.reloading.IClassPathItem.getSubpackages(String)	there are 2 uses of the method, 1 is to be replaced with IClassPathItem.hasPackage(String), another shall get refactored as there's no need in specific iteration order
jetbrains.mps.smodel.adapter.ids.MetaIdFactory.conceptId(UUID, long)
jetbrains.mps.smodel.adapter.ids.MetaIdFactory.langId(UUID)
jetbrains.mps.smodel.adapter.ids.MetaIdFactory.linkId(UUID, long, long)
jetbrains.mps.smodel.adapter.ids.MetaIdFactory.propId(UUID, long, long)
jetbrains.mps.smodel.adapter.ids.MetaIdFactory.refId(UUID, long, long)
jetbrains.mps.smodel.adapter.structure.concept.SAbstractConceptAdapter.getDeclarationNode()
jetbrains.mps.smodel.adapter.structure.MetaAdapterFactoryByName.getConcept(String)
jetbrains.mps.smodel.adapter.structure.MetaAdapterFactoryByName.getContainmentLink(String, String)
jetbrains.mps.smodel.adapter.structure.MetaAdapterFactoryByName.getInterfaceConcept(String)
jetbrains.mps.smodel.adapter.structure.MetaAdapterFactoryByName.getProperty(String, String)
jetbrains.mps.smodel.adapter.structure.MetaAdapterFactoryByName.getReferenceLink(String, String)
jetbrains.mps.smodel.behaviour.BHReflection.invoke(SNode, SMethodId, Object...)	operand is not null actually, use #invoke0 below instead
jetbrains.mps.smodel.constraints.ReferenceDescriptor.getReferencePresentation(SNode, boolean, boolean, boolean)	uses only in the editor
jetbrains.mps.smodel.constraints.ReferenceDescriptor.getScopeProvider()	this class shall not expose its implementation detail, otherwise there's no point in its presence. refactor the single use and remove this method, it's our internal api. Perhaps, we need a distinct validator object?
jetbrains.mps.smodel.event.SModelLanguageEvent.getLanguageNamespace()	use SModelLanguageEvent.getEventLanguage() instead. We stick to SLanguage for model's used languages.
jetbrains.mps.smodel.event.SModelListener.beforeModelFileChanged(SModelFileChangedEvent)	MPS will cease to send out this event, use DataSourceListener instead
jetbrains.mps.smodel.event.SModelListener.modelFileChanged(SModelFileChangedEvent)	MPS will cease to send out this event, use DataSourceListener instead
jetbrains.mps.smodel.event.SModelListener.rootAdded(SModelRootEvent)	use SNodeChangeListener.nodeAdded(org.jetbrains.mps.openapi.event.SNodeAddEvent)
jetbrains.mps.smodel.event.SModelListener.rootRemoved(SModelRootEvent)	use SNodeChangeListener.nodeRemoved(org.jetbrains.mps.openapi.event.SNodeRemoveEvent)
jetbrains.mps.smodel.Generator.getSourceLanguage()	Hard link to Language module makes Generator modules inflexible and bound to Language presence. Use Generator.sourceLanguage() instead
jetbrains.mps.smodel.InterfaceSNode.skipRole(String)
jetbrains.mps.smodel.language.ConceptRegistry.getBehaviorRegistry()	use
jetbrains.mps.smodel.language.ConceptRegistry.getConceptByName(String)
jetbrains.mps.smodel.language.ConceptRegistry.getConceptDescriptor(SAbstractConcept)	It's odd to go from SAbstractConcept back to ConceptDescriptor. It's MPS implementation of SConcept that deals with ConceptDescriptors to populate SAbstractConcept and client code shall not reverse this. * NOTE, THERE ARE NO USES left in MPS code, don't introduce a new one! We'll drop the method any time soon. *
jetbrains.mps.smodel.language.ConceptRegistryUtil.getConceptDescriptor(SConceptId)
jetbrains.mps.smodel.language.ExtensionRegistry.getInstance()	avoid static access, replace with componentHost.findComponent(ExtensionRegistry.class)
jetbrains.mps.smodel.Language.getConceptDeclarations()	method is not bad per se (Language module could tell SNode with concept declaration. However, it silently excludes Interface concepts, and likely its uses need attention and switch to SConcept. Then, we could decide whether we truly need access to language's concept nodes this way, or shall use LanguageAspects instead.
jetbrains.mps.smodel.Language.getModelAspect(SModel)
jetbrains.mps.smodel.language.LanguageAspectDescriptor.getIcon()
jetbrains.mps.smodel.language.LanguageAspectSupport.getInitialDevKits(SModel)
jetbrains.mps.smodel.language.LanguageAspectSupport.getNewAspect(SModel)
jetbrains.mps.smodel.language.LanguageAspectSupport.getOldAspect(SModel)
jetbrains.mps.smodel.language.LanguageRegistry.getGenerator(Generator)	use LanguageRegistry.getGenerator(SModuleReference) as it's SModuleReference that is generator identity.
jetbrains.mps.smodel.language.LanguageRegistry.getInstance()	obtain instance through componentHost#findComponent(LanguageRegistry.class) or use context-specific alternative LanguageRegistry.getInstance(SRepository).
jetbrains.mps.smodel.Language.setLanguageDescriptor(LanguageDescriptor)
jetbrains.mps.smodel.LanguageAspect.getAspectModels(Language)
jetbrains.mps.smodel.LanguageAspect.getMainLanguage()
jetbrains.mps.smodel.ModelAccess.instance()
jetbrains.mps.smodel.ModelAccess.setReadEnabledFlag(boolean)
jetbrains.mps.smodel.ModelCommandExecutor.flushEventQueue()	with no contract, what could justify its use?
jetbrains.mps.smodel.ModelCommandExecutor.isInsideCommand()	Use ModelAccess.isCommandAction() instead
jetbrains.mps.smodel.ModelCommandExecutor.setReadEnabledFlag(boolean)	Shall get replaced with full-fledged 'token' object
jetbrains.mps.smodel.ModelCommandExecutor.tryRead(Runnable)	There are no uses in MPS itself, switch to CancellableReadAction if utterly needed
jetbrains.mps.smodel.ModuleRepositoryFacade.createModule(ModulesMiner.ModuleHandle, MPSModuleOwner)	use instance counterpart ModuleRepositoryFacade.instantiateModule(ModuleHandle, MPSModuleOwner) instead.
jetbrains.mps.smodel.ModuleRepositoryFacade.getAllExtendingLanguages(Language)	If there's need for extending language, shall add Language.getDirectlyExtendingLanguage. There's single use in mbeddr.
jetbrains.mps.smodel.ModuleRepositoryFacade.getInstance()
jetbrains.mps.smodel.ModuleRepositoryFacade.getModelByName(String)	there could be more than 1 model with the same name, use ModuleRepositoryFacade.getModelsByName(SModelName) and pick the one you need. This is provisional API to keep all uses of SModelRepository.getModelDescriptor(String) in a single, controlled place. I could had had created ModelRepositoryFacade, similar to this class, however, it seems just too much for a single method that we shall drop anyway.
jetbrains.mps.smodel.MPSModuleRepository.getInstance()
jetbrains.mps.smodel.MPSModuleRepository.unregisterModules(Collection<SModule>, MPSModuleOwner)	use of this method is discouraged as it's specific to this SRepository implementation. It shall not get exposed in SRepositoryExt unless there's thorough justification. The only rationale behind this method was slow 'invalidateCaches()' when multiple modules were un-registered during project close/MPS shutdown. Now, with no-op invalidateCaches(), there's no performance gain in using this method. However, might be reasonable to update SRepositoryExt API to accommodate collection instead of a single object for register/unregister operations. The method left as a reminder.
jetbrains.mps.smodel.persistence.def.ModelPersistence.index(byte[], IndexAwareModelFactory.Callback)	use ModelPersistence.index(InputStream, Callback) instead
jetbrains.mps.smodel.presentation.NodePresentationUtil.descriptionText(SAbstractConcept, boolean)	use NodePresentationUtil.descriptionText(SAbstractConcept) instead
jetbrains.mps.smodel.presentation.NodePresentationUtil.matchingText(SAbstractConcept, boolean)	use NodePresentationUtil.matchingText(SAbstractConcept) instead.
jetbrains.mps.smodel.presentation.ReferenceConceptUtil.getCharacteristicReference(SNode)
jetbrains.mps.smodel.presentation.ReferenceConceptUtil.getPresentationFromSmartAlias(SNode, String)
jetbrains.mps.smodel.presentation.ReferenceConceptUtil.hasSmartAlias(SNode)
jetbrains.mps.smodel.PropertySupport.canSetValue(SNode, String, String, boolean)
jetbrains.mps.smodel.PropertySupport.getPropertySupport(SProperty)
jetbrains.mps.smodel.runtime.base.BaseConstraintsDescriptor.hasOwnDefaultScopeProvider()
jetbrains.mps.smodel.runtime.base.BaseReferenceConstraintsDescriptor.getReferenceLink()
jetbrains.mps.smodel.runtime.ConceptPresentationBuilder.deprecated(SConceptFeature...)	use ConceptPresentationBuilder.deprecateProperty(long, String) or ConceptPresentationBuilder.deprecateAggregation(long, String) instead Keep it until 2017.2 is out; code generated with 2017.1 uses this method
jetbrains.mps.smodel.runtime.IconResource.getResource()
jetbrains.mps.smodel.runtime.IconResource.isAlreadyReloaded()
jetbrains.mps.smodel.runtime.impl.ConceptDescriptorBuilder2.prop(String, long, String)	use ConceptDescriptorBuilder2.property(String, long) instead.
jetbrains.mps.smodel.runtime.ReferenceConstraintsContext.getContainingLink()	use ReferenceConstraintsContext.getContainmentLink() instead
jetbrains.mps.smodel.runtime.ReferenceConstraintsContext.getContextRole()	use ReferenceConstraintsContext.getContainmentLink() instead
jetbrains.mps.smodel.runtime.ReferenceConstraintsContext.getEnclosingNode()	equals to getReferenceNode() != null ? getReferenceNode().getParent() : getContextNode()
jetbrains.mps.smodel.runtime.ReferenceConstraintsContext.getLinkTarget()	use ReferenceConstraintsContext.getLinkTargetConcept() instead
jetbrains.mps.smodel.runtime.ReferenceConstraintsContext.getModel()	use context.getContextNode().getModel() instead
jetbrains.mps.smodel.runtime.ReferenceConstraintsContext.isExists()	use context.getReferenceNode().getReference(link) != null instead
jetbrains.mps.smodel.runtime.ReferenceConstraintsDescriptor.getName()
jetbrains.mps.smodel.runtime.ReferenceConstraintsDescriptor.getReferenceLink()
jetbrains.mps.smodel.search.SModelSearchUtil.findLinkDeclaration(SNode, String)
jetbrains.mps.smodel.search.SModelSearchUtil.findPropertyDeclaration(SNode, String)
jetbrains.mps.smodel.search.SModelSearchUtil.getLinkDeclarations(SNode)
jetbrains.mps.smodel.search.SModelSearchUtil.getPropertyDeclarations(SNode)
jetbrains.mps.smodel.SModel.engagedOnGenerationLanguages()	though it's our internal API, there's 1 use in mbeddr of this exact method we need to fix first. Once mbeddr use and 2 uses in our model persistence gone, remove the method
jetbrains.mps.smodel.SModelId.fromString(String)	this method doesn't support SModelIdFactory, use PersistenceFacade.createModelId(String) instead.
jetbrains.mps.smodel.SModelOperations.allImportedModels(SModel)	use ModelDependencyResolver instead
jetbrains.mps.smodel.SModelOperations.getAllLanguageImports(SModel)	use ModelDependencyResolver instead
jetbrains.mps.smodel.SModelReference.parseReference(String)	This code shall move to private method of PersistenceRegistry, which would dispatch to proper registered factories. Use PersistenceFacade.createModelReference(String) instead. Format: [ moduleID / ] modelID [ ([moduleName /] modelName ) ]
jetbrains.mps.smodel.SModelRepository.getInstance()	global collection of SModels doesn't allow us to move forward. Do not use.
jetbrains.mps.smodel.SModelRepository.getModelDescriptor(SModelReference)	this method makes sense for globally unique model id only, but doesn't manifest this contract. Use SModelReference.resolve(SRepository) instead
jetbrains.mps.smodel.SModelRepository.getModelDescriptorsByModelName(String)
jetbrains.mps.smodel.SModelStereotype.getStereotype(String)	use SModelName.getStereotype()
jetbrains.mps.smodel.SModelStereotype.isStubModelStereotype(String)	use SModelStereotype.isStubModel(SModel) instead, plain strings instead of objects are just bad design
jetbrains.mps.smodel.SModelUtil_new.instantiateConceptDeclaration(SNode, SModel, boolean)	use of this method is discouraged as it exposes SNode implementation class. There's SModelOperations.createNewNode() to use from generated code
jetbrains.mps.smodel.SNode.addChild(String, SNode)
jetbrains.mps.smodel.SNode.getChildren(String)
jetbrains.mps.smodel.SNode.getProperty(String)
jetbrains.mps.smodel.SNode.getPropertyNames()
jetbrains.mps.smodel.SNode.getReference(String)
jetbrains.mps.smodel.SNode.getReferenceTarget(String)
jetbrains.mps.smodel.SNode.getRoleInParent()
jetbrains.mps.smodel.SNode.hasProperty(String)
jetbrains.mps.smodel.SNode.insertChildBefore(String, SNode, SNode)
jetbrains.mps.smodel.SNode.setProperty(String, String)
jetbrains.mps.smodel.SNode.setReference(String, SReference)
jetbrains.mps.smodel.SNode.setReferenceTarget(String, SNode)
jetbrains.mps.smodel.SNodeId.fromString(String)	technically, the method is ok, if you know exactly which node id you parse. marked deprecated to get uses noticed and replaced with PersistenceFacade.createNodeId(String)
jetbrains.mps.smodel.SNodeUndoableAction.hasVirtualFile()	since MPS 2017.3 all undo actions are associated with virtual files. Not used anymore.
jetbrains.mps.smodel.SNodeUndoableAction.isGlobal()	since MPS 2017.3 use SNodeUndoableAction.getAssociatedVfsChange() instead.
jetbrains.mps.smodel.SNodeUtil.isDefaultSubstitutable(SAbstractConcept)	Since 2017.1 editor automatically detects whether the concept cannot be used as a substitute by noticing that its substitute menu is empty
jetbrains.mps.smodel.SReference.create(String, SNode, SModelReference, SNodeId)
jetbrains.mps.smodel.SReference.getRole()
jetbrains.mps.smodel.StaticReference.getTargetSModel()	(1) Implementation detail, shall be private. Now, with ClassCreator that no longer casts to StaticReference to access this method, can be made private. LEAVE as public till the end of 2018.3 release cycle to give clients time to update, just in case, make private once 2018.3 is out (2) Is flawed with respect to global repository assumption, references are resolved with null repository To be replaced with #getTargetModel_Fair
jetbrains.mps.smodel.structure.ExtensionPoint.getExtensions()	obtain ExtensionRegistry instance through ComponentHost.findComponent(Class) and invoke BaseExtensionRegistry.getExtensions(ExtensionPoint), instead
jetbrains.mps.smodel.structure.ExtensionPoint.getObjects()	obtain ExtensionRegistry instance through ComponentHost.findComponent(Class) and invoke BaseExtensionRegistry.getObjects(ExtensionPoint), instead
jetbrains.mps.smodel.undo.UndoContext.getVirtualFileNodes(List<SNodeUndoableAction>)	Use getVirtualFileNodes(SNodeUndoableAction actions) instead
jetbrains.mps.smodel.UndoHelper.flushCommand()	This method is unused, no-op and scheduled for removal, just don't use it any more
jetbrains.mps.smodel.UndoHelper.startCommand(UndoContext)	This method is unused, no-op and scheduled for removal, just don't use it any more
jetbrains.mps.stubs.javastub.classpath.ClassifierKind.getClassifierKind(InputStream)
jetbrains.mps.textgen.trace.TraceInfo.getPositionForNode(SNode)	use TraceInfo.getPosition(SNode) instead
jetbrains.mps.textgen.trace.TraceInfo.hasTrace(SModel)	use instance method TraceInfo.hasDebugInfo(SModel) instead When removing, consider instance method with same name.
jetbrains.mps.textgen.trace.TraceInfo.unitNames(SNode)	use TraceInfo.getUnitNames(SNode) instead
jetbrains.mps.textgen.trace.TraceInfoCache.getInstance()	instead, create a new instance for a series of trace.info access. We don't track these files any more, it's up to caller to decide lifespan of the cache.
jetbrains.mps.textgen.trace.TracingUtil.fillOriginalNode(SNode, SNode, boolean)	code branching done with boolean flag.
jetbrains.mps.tool.environment.EnvironmentConfig.addPluginClassPath(String)	unused value, just drop uses
jetbrains.mps.tool.environment.EnvironmentConfig.getPluginClassPath()	unused, no reason to keep
jetbrains.mps.typesystem.inference.SubtypingManager.mostSpecificTypes(Set<SNode>)	use SubtypingUtil
jetbrains.mps.typesystem.inference.TypeCheckingContext.createComparableEquation(SNode, SNode, SNode, String, String, String, QuickFixProvider)
jetbrains.mps.typesystem.inference.TypeCheckingContext.createEquation(SNode, SNode, SNode, String, String, String, QuickFixProvider)
jetbrains.mps.typesystem.inference.TypeCheckingContext.createGreaterThanInequation(SNode, SNode, SNode, String, String, String, boolean, int, QuickFixProvider)
jetbrains.mps.typesystem.inference.TypeCheckingContext.createLessThanInequationStrong(SNode, SNode, SNode, String, String, String, boolean, int, QuickFixProvider)
jetbrains.mps.typesystem.inference.TypeCheckingContext.getBaseNodeTypesComponent()
jetbrains.mps.util.CollectionUtil.filter(List<? extends T>, Condition<T>)
jetbrains.mps.util.EqualUtil.equals(Object, Object)
jetbrains.mps.util.EqualUtil.hashCode(Object)
jetbrains.mps.util.FileUtil.getUnixPath(String)
jetbrains.mps.util.FileUtil.resolveParentDirs(String)
jetbrains.mps.util.MacrosFactory.forModule(AbstractModule)	why would anyone care to cast openapi.SModule to AbstractModule? Use MacrosFactory.forModule(SModule) instead.
jetbrains.mps.util.NameUtil.getModelLongName(SModel)	Use SModelName.getLongName() instead
jetbrains.mps.util.performance.IPerformanceTracer.push(String, boolean)	parameter isMajor is useless, use IPerformanceTracer.push(String)
jetbrains.mps.util.ProtectionDomainUtil.loadedClassDomain()	(since 3.2)
jetbrains.mps.util.SNodeOperations.copyProperties(SNode, SNode)	use node/../.copy or copy manually
jetbrains.mps.util.SNodeOperations.copyUserObjects(SNode, SNode)	don't use user objects, store them separately
jetbrains.mps.util.SNodeOperations.findParent(SNode, Condition<SNode>)	use node/../.ancestors.where
jetbrains.mps.util.SNodeOperations.getChild(SNode, SContainmentLink)	use node/../.child or SNode.getChildren
jetbrains.mps.util.SNodeOperations.getChildren(SNode, boolean)	there is no full equivalent to this, use SNode.getChildren or node/../.children operations if possible
jetbrains.mps.util.SNodeOperations.getChildRoles(SNode)	rewrite to SContainmentLink, don't use by-name roles, use SNode methods
jetbrains.mps.util.SNodeOperations.getDebugText(SNode)	use SNode.getName, SNode.getModel or whatever info you really need.
jetbrains.mps.util.SNodeOperations.getModelLongName(SModel)	inline
jetbrains.mps.util.SNodeOperations.getModelStereotype(SModel)	inline
jetbrains.mps.util.SNodeOperations.getProperties(SNode)	rewrite to SProperty, don't use strings
jetbrains.mps.util.SNodeOperations.getReferenceRoles(SNode)	use either SNode.getReference.select(it->it.role) or SNode.getConcept.getReferenceLinks depending on what you want to get
jetbrains.mps.util.SNodeOperations.getReferences(SNode)	use SNode.getReferences
jetbrains.mps.util.SNodeOperations.getResolveInfo(SNode)	use SNodeUtil.getResolveInfo (note it does not return name in case of !isInstanceOf(IResolveInfo))
jetbrains.mps.util.SNodeOperations.getTargetNodeSilently(SReference)	not supposed to be used not in MPS core. Use ref.getTargetNode
jetbrains.mps.util.SNodeOperations.isAncestor(SNode, SNode)	use .ancestors.contains() in smodel language
jetbrains.mps.util.SNodeOperations.isGeneratable(SModel)	not supposed to be used outside of MPS core, inline if you use it
jetbrains.mps.util.SNodeOperations.isModelDisposed(SModel)	use model.getRepository!=null. AP: I tried and it is not the same. Why?
jetbrains.mps.util.SNodeOperations.isRegistered(SModel)	use model.getRepository!=null
jetbrains.mps.util.SNodeOperations.isRoot(SNode)	SNode.getParent!=null mostly (if done in "user" code which operates with nodes inside models)
jetbrains.mps.util.SNodeOperations.nodesCount(SModel)	inline
jetbrains.mps.validation.ValidationSettings.getCheckerRegistry()	CheckerRegistry is CoreComponent, use ComponentHost.findComponent(Class) to obtain its instance To my best knowledge, there are no uses of this method in mbeddr.
jetbrains.mps.vfs.FileSystem.getFile(String)
jetbrains.mps.vfs.FileSystem.getInstance()
jetbrains.mps.vfs.FileSystem.isFileIgnored(String)
jetbrains.mps.vfs.FileSystem.runWriteTransaction(Runnable)
jetbrains.mps.vfs.IFile.addListener(FileListener)	move to CachingFile
jetbrains.mps.vfs.IFile.getBundleHome()	use IFile.getPath() and extract the path you need
jetbrains.mps.vfs.IFile.getDescendant(String)	use findChild() instead. The problem of findDescendant is that it's unclear, can we pass an empty string, string with path separators, string with archive separators
jetbrains.mps.vfs.IFile.getFileSystem()
jetbrains.mps.vfs.IFile.getUrl()
jetbrains.mps.vfs.IFile.isArchive()
jetbrains.mps.vfs.IFile.isPackaged()	use IFile.isArchive() or IFile.isInArchive()
jetbrains.mps.vfs.IFile.length()
jetbrains.mps.vfs.IFile.refresh()	use CachingFile.refresh(CachingContext)
jetbrains.mps.vfs.impl.IoFileSystem.getFile(String)
jetbrains.mps.vfs.iofs.jrt.JrtIoFile.getUrl()
jetbrains.mps.vfs.openapi.FileSystem.getFile(String)
jetbrains.mps.vfs.refresh.CachingFile.getDescendant(String)
jetbrains.mps.vfs.refresh.FileSystemListener.getListenerDependencies()
org.jetbrains.mps.openapi.language.SAbstractConcept.getDeclarationNode()
org.jetbrains.mps.openapi.language.SAbstractConcept.getQualifiedName()
org.jetbrains.mps.openapi.language.SAbstractLink.getRole()	use SNamedElement.getName()
org.jetbrains.mps.openapi.language.SAbstractLink.isReference()	boolean limits API to two link kinds possible
org.jetbrains.mps.openapi.language.SContainmentLink.getDeclarationNode()
org.jetbrains.mps.openapi.language.SContainmentLink.getRoleName()
org.jetbrains.mps.openapi.language.SLanguage.getLanguageVersion()
org.jetbrains.mps.openapi.language.SProperty.getDeclarationNode()
org.jetbrains.mps.openapi.language.SReferenceLink.getDeclarationNode()
org.jetbrains.mps.openapi.language.SReferenceLink.getRoleName()
org.jetbrains.mps.openapi.language.SReferenceLink.isMultiple()
org.jetbrains.mps.openapi.model.SModel.getModelName()	Prefer SModel.getName() with access to distinct fractions of the name
org.jetbrains.mps.openapi.model.SModel.Problem.getNode()	use SModel.Problem.getAnchorNode() instead
org.jetbrains.mps.openapi.model.SNode.addChild(String, SNode)	use addChild(SContainmentLink, SNode)
org.jetbrains.mps.openapi.model.SNode.getChildren(String)	use getChildren(SContainmentLink)
org.jetbrains.mps.openapi.model.SNode.getProperty(String)	use getProperty(SProperty)
org.jetbrains.mps.openapi.model.SNode.getPropertyNames()	use getProperties()
org.jetbrains.mps.openapi.model.SNode.getReference(String)	use getReference(SReferenceLink)
org.jetbrains.mps.openapi.model.SNode.getReferenceTarget(String)	use getReferenceTarget(SReferenceLink)
org.jetbrains.mps.openapi.model.SNode.getRoleInParent()	use getContainmentLink()
org.jetbrains.mps.openapi.model.SNode.hasProperty(String)	use hasProperty(SProperty)
org.jetbrains.mps.openapi.model.SNode.insertChildBefore(String, SNode, SNode)	use insertChildBefore(SContainmentLink, SNode, SNode)
org.jetbrains.mps.openapi.model.SNode.setProperty(String, String)	use setProperty(SProperty)
org.jetbrains.mps.openapi.model.SNode.setReference(String, SReference)	use setReference(SReferenceLink, SReference)
org.jetbrains.mps.openapi.model.SNode.setReferenceTarget(String, SNode)	use setReferenceTarget(SReferenceLink, SNode)
org.jetbrains.mps.openapi.model.SNodeAccessUtil.getProperty(SNode, SProperty)	This method returns serialized property value. Consider use SNodeAccessUtil.setPropertyValue(SNode, SProperty, Object) that supplies values as is
org.jetbrains.mps.openapi.model.SNodeAccessUtil.hasProperty(SNode, String)
org.jetbrains.mps.openapi.model.SNodeAccessUtil.setProperty(SNode, SProperty, String)	This method takes serialized property value. Consider use SNodeAccessUtil.setPropertyValue(SNode, SProperty, Object) that consumes values as is
org.jetbrains.mps.openapi.model.SNodeAccessUtil.setReference(SNode, String, SReference)
org.jetbrains.mps.openapi.model.SNodeAccessUtil.setReferenceTarget(SNode, String, SNode)
org.jetbrains.mps.openapi.model.SReference.getRole()
org.jetbrains.mps.openapi.module.FacetsFacade.FacetFactory.create()	override FacetsFacade.FacetFactory.create(SModule) instead.
org.jetbrains.mps.openapi.module.FacetsFacade.getInstance()	Use respective ComponentPlugin (i.e. MPSCore) to obtain instance of the registry.
org.jetbrains.mps.openapi.module.FindUsagesFacade.findInstances(SearchScope, Set<? extends SAbstractConcept>, boolean, ProgressMonitor)	please use more general version below. consider using jetbrains.mps.util.CollectConsumer if you need to recreate the old behavior.
org.jetbrains.mps.openapi.module.FindUsagesFacade.findModelUsages(SearchScope, Set<SModelReference>, ProgressMonitor)	please use more general version below. consider using jetbrains.mps.util.CollectConsumer if you need to recreate the old behavior.
org.jetbrains.mps.openapi.module.FindUsagesFacade.findUsages(SearchScope, Set<SNode>, ProgressMonitor)	please use more general version below. consider using jetbrains.mps.util.CollectConsumer if you need to recreate the old behavior.
org.jetbrains.mps.openapi.module.SRepository.getParent()
org.jetbrains.mps.openapi.module.SRepository.getRepositoryAccess()
org.jetbrains.mps.openapi.module.SRepositoryListener.repositoryCommandFinished(SRepository)
org.jetbrains.mps.openapi.module.SRepositoryListener.repositoryCommandStarted(SRepository)
org.jetbrains.mps.openapi.module.SRepositoryListener.updateFinished(SRepository)
org.jetbrains.mps.openapi.module.SRepositoryListener.updateStarted(SRepository)
org.jetbrains.mps.openapi.persistence.ModelFactory.canCreate(DataSource, Map<String, String>)	rather try calling ModelFactory.create(DataSource, SModelName, ModelLoadingOption...) method and catching the ModelCreationException during creation or use ModelFactory.supports(DataSource) method to acknowledge whether this data source is supported at all.
org.jetbrains.mps.openapi.persistence.ModelRoot.canCreateModel(String)	we have a DataSourceFactory#create + ModelFactory.create(DataSource, SModelName, ModelLoadingOption...) to create a new model (from a new data source) having just a model name and a model root. this method gives out an insufficient API -- it kind of implies that a model root has the only way to create a model given a name, however obviously it is not true in a current MPS setup. Semantics of this method (as for 3.5) is to create a new model via default DataSourceFactory and default ModelFactory. Not sure if it makes sense at all shaped like this. The signature needs to be extended with a ModelFactory parameter. The same applies to the #createModel as well. [AP]
org.jetbrains.mps.openapi.persistence.ModelRoot.canCreateModels()	use specific #canCreateModel(SModelName)
org.jetbrains.mps.openapi.persistence.PersistenceFacade.addFindUsagesParticipant(FindUsagesParticipant)	add/remove methods shall move to PersistenceRegistry (implementation class), instead, as components that perform registration may access PersistenceRegistry instance directly. I don't see a need to add/remove participants dynamically.
org.jetbrains.mps.openapi.persistence.PersistenceFacade.addNavigationParticipant(NavigationParticipant)	see PersistenceFacade.addFindUsagesParticipant(FindUsagesParticipant) for reasons
org.jetbrains.mps.openapi.persistence.PersistenceFacade.getDefaultModelFactory()	unclear contract, use ModelFactoryRegistry#getDefault(DataSourceType) + PreinstalledModelFactoryTypes.PLAIN_XML
org.jetbrains.mps.openapi.persistence.PersistenceFacade.getModelFactory(String)	use PersistenceFacade.getModelFactory(ModelFactoryType) instead
org.jetbrains.mps.openapi.persistence.PersistenceFacade.removeFindUsagesParticipant(FindUsagesParticipant)	see PersistenceFacade.addFindUsagesParticipant(FindUsagesParticipant) for reasons
org.jetbrains.mps.openapi.persistence.PersistenceFacade.removeNavigationParticipant(NavigationParticipant)	see PersistenceFacade.addFindUsagesParticipant(FindUsagesParticipant) for reasons

Constructors

Constructor	Description
jetbrains.mps.analyzers.runtime.framework.DataFlowConstructor()
jetbrains.mps.build.ant.AllModulesDataType()
jetbrains.mps.build.ant.ModuleJarDataType()
jetbrains.mps.cache.CachesManager(ClassLoaderManager, SRepository)	Use of this cache is discouraged. There's only 1 use in MPS and it doesn't justify existence of this class, imo. We shall switch ModelEventRouter to use openapi events if the class persists.
jetbrains.mps.errors.AbstractErrorReporter(String, String)
jetbrains.mps.extapi.model.PersistenceProblem(SModel.Problem.Kind, String, String, boolean, int, int, SNode)	use alternative with node reference for anchor
jetbrains.mps.extapi.persistence.FileBasedModelRoot(String[])	use FileBasedModelRoot() instead and define your own FileBasedModelRoot.getSupportedFileKinds1()
jetbrains.mps.extapi.persistence.FileDataSource(IFile, ModelRoot)	use DataSourceFactoryRuleService.getFactory(org.jetbrains.mps.openapi.persistence.datasource.DataSourceType) AND DataSourceFactoryFromName.create(org.jetbrains.mps.openapi.model.SModelName, jetbrains.mps.extapi.persistence.SourceRoot)
jetbrains.mps.extapi.persistence.FileWithBackupDataSource(IFile, ModelRoot)
jetbrains.mps.extapi.persistence.FolderDataSource(IFile, ModelRoot)
jetbrains.mps.internal.make.runtime.java.FileDeltaCollector(IFile, FileProcessor)	use FileDeltaCollector(FilesDelta, IFile, FileProcessor) instead
jetbrains.mps.internal.make.runtime.util.FilesDelta(IFile)	use cons that takes DeltaKey, as use of IFile here is confusing, it's merely a hierarchical indicator to merge deltas, and is unrelated to IFiles recorded.
jetbrains.mps.lang.smodel.generator.smodelAdapter.SLinkOperations()
jetbrains.mps.library.ModulesMiner()	use ModulesMiner(Collection, DescriptorIOFacade) instead
jetbrains.mps.make.java.RootDependencies(String, String, List<String>, List<String>)	Shall move fileName (if needed at all) to ModelDependencies
jetbrains.mps.make.script.IProgress.Stub()
jetbrains.mps.persistence.DataSourceFactoryBridge(FileBasedModelRoot)	use DataSourceFactoryBridge(FileBasedModelRoot, DataSourceFactoryRuleService) instead
jetbrains.mps.persistence.DefaultModelRoot()	Use DefaultModelRoot.createDescriptor(IFile, IFile...) if you need to populate ModuleDescriptor. Proper cons (package-local) shall get invoked from ModelRootFactory only.
jetbrains.mps.persistence.FilePerRootDataSource(IFile, ModelRoot)
jetbrains.mps.project.AbstractModule()
jetbrains.mps.project.Project(String, Function<Project, ProjectRepository>)	this is an ugly way to pass Project instance into ProjectRepository cons
jetbrains.mps.project.structure.modules.Dependency()	use the other constructors instead
jetbrains.mps.project.structure.ProjectStructureModule(SRepositoryExt, PersistenceFacade)
jetbrains.mps.refactoring.framework.RefactoringUtil()
jetbrains.mps.smodel.DynamicReference(String, SNode, SModelReference, String)
jetbrains.mps.smodel.ModuleRepositoryFacade(MPSModuleRepository)	This class shall cease to be CoreComponent and singleton. Instead, shall be instantiated directly with ModuleRepositoryFacade(SRepository) when our implementation code need to deal with repository internals
jetbrains.mps.smodel.runtime.base.BasePropertyConstraintsDescriptor(SPropertyId, ConstraintsDescriptor)
jetbrains.mps.smodel.runtime.base.BaseReferenceConstraintsDescriptor(SReferenceLinkId, ConstraintsDescriptor)
jetbrains.mps.smodel.runtime.BaseLinkDescriptor(SContainmentLinkId, String, SConceptId, boolean, boolean, boolean)
jetbrains.mps.smodel.runtime.BasePropertyDescriptor(SPropertyId, String)
jetbrains.mps.smodel.runtime.BaseReferenceDescriptor(SReferenceLinkId, String, SConceptId, boolean)
jetbrains.mps.smodel.search.SModelSearchUtil()
jetbrains.mps.smodel.SLanguageHierarchy(Collection<SLanguage>)
jetbrains.mps.smodel.SModel.ImportElement(SModelReference, int)
jetbrains.mps.smodel.SReference(String, SNode)
jetbrains.mps.smodel.StaticReference(String, SNode, SNode)
jetbrains.mps.smodel.structure.ExtensionPoint(String, Class<T>)
jetbrains.mps.tool.builder.make.ConsoleMessageFormat()
jetbrains.mps.tool.builder.paths.OutputPathRedirects(ModuleOutputPaths, String, String, boolean)	there's no reason to bound IRedirects to string, if we know about IFile anyway. OutputPathRedirects shall not make assumptions about FS (or shall get FS as cons argument directly). Use OutputPathRedirects(ModuleOutputPaths, IFile, IFile, boolean)instead.
jetbrains.mps.tool.common.TeamCityMessageFormat()
jetbrains.mps.util.Icon2IconResourceAdapter_Deprecated(Icon)