@Nullable /*package*/ SNode getTypeOf(final SNode node) { ModelAccess.assertLegalRead(); if (node == null) return null; if (myTypeChecker.isGenerationMode()) { TypeCheckingContext context = myTypeChecker.hasPerformanceTracer() ? new TargetTypecheckingContext_Tracer(node, myTypeChecker) : new TargetTypecheckingContext(node, myTypeChecker); try { return context.getTypeOf_generationMode(node); } finally { context.dispose(); } } // now we are not in generation mode final ITypeContextOwner contextOwner = myTypecheckingContextOwner.get(); TypeCheckingContext context = acquireTypecheckingContext(node, contextOwner); if (context == null) { return TypesUtil.createRuntimeErrorType(); } try { return context.getTypeOf(node, myTypeChecker); } finally { releaseTypecheckingContext(node, contextOwner); } }
public TypeCheckingContext createTypeCheckingContext(SNode node) { ModelAccess.assertLegalRead(); if (myTypeChecker.isGenerationMode()) { return new TargetTypecheckingContext(node, myTypeChecker); } else { return new IncrementalTypecheckingContext(node, myTypeChecker); } }
public void rehighlightAllFeaturesNow() { ModelAccess.assertLegalRead(); synchronized (myFeaturesHolder) { for (Feature f : ListSequence.fromList(myFeaturesHolder.getAllModelFeatures())) { rehighlightFeatureAndDescendants(f); } } }
public Iterable<TransientModelsModule> getModules() { ModelAccess.assertLegalRead(); List<TransientModelsModule> result = new ArrayList<TransientModelsModule>(myModuleMap.size()); for (TransientModelsModule m : myModuleMap.values()) { if (m.hasPublished()) { result.add(m); } } return result; }
private void removeOwnerForRootNodeContext(final SNode node, final ITypeContextOwner owner) { ModelAccess.assertLegalRead(); if (node == null || node.getModel() == null) return; final SNode rootNode = node.getContainingRoot(); // if node is disposed, then context was removed by beforeModelDisposed/beforeRootDeleted // listener synchronized (myLock) { SNodeReference rootNodePointer = new jetbrains.mps.smodel.SNodePointer(rootNode); List<TypecheckingContextHolder> contextWithOwners = myTypeCheckingContexts.get(rootNodePointer); if (contextWithOwners != null) { for (ListIterator<TypecheckingContextHolder> it = contextWithOwners.listIterator(); it.hasNext(); ) { TypecheckingContextHolder contextHolder = it.next(); ITypeContextOwner o = contextHolder.getOwner(); if (o == owner) { if (!owner.reuseTypecheckingContext()) { contextHolder.release(); if (!contextHolder.isActive()) { it.remove(); } } else { contextHolder.release(); if (!contextHolder.isActive()) { it.remove(); } } break; } } if (contextWithOwners.isEmpty()) { myTypeCheckingContexts.remove(rootNodePointer); } } } }
private TypeCheckingContext getOrCreateContext( SNode node, ITypeContextOwner owner, boolean createIfAbsent) { ModelAccess.assertLegalRead(); if (node == null) return null; final SNode rootNode = node.getContainingRoot(); synchronized (myLock) { SNodeReference rootNodePointer = new jetbrains.mps.smodel.SNodePointer(rootNode); List<TypecheckingContextHolder> contextWithOwners = myTypeCheckingContexts.get(rootNodePointer); if (contextWithOwners == null && !createIfAbsent) return null; if (contextWithOwners == null) { contextWithOwners = new ArrayList<TypecheckingContextHolder>(4); myTypeCheckingContexts.put(rootNodePointer, contextWithOwners); } for (ListIterator<TypecheckingContextHolder> it = contextWithOwners.listIterator(); it.hasNext(); ) { TypecheckingContextHolder contextHolder = it.next(); if (contextHolder.getOwner() == owner) { if (!owner.reuseTypecheckingContext()) { assert createIfAbsent; return contextHolder.acquire(node); } else { // reuse the typechecking context if (!createIfAbsent) { return contextHolder.get(node); } final TypeCheckingContext ctx = contextHolder.acquire(node); // Dirty hack if (jetbrains.mps.util.SNodeOperations.isDisposed(ctx.getNode())) { removeContextForNode(rootNodePointer); LOG.error( "Type Checking Context had a disposed node inside. Node: " + node + " model: " + node.getModel()); return getOrCreateContext(node, owner, createIfAbsent); } return ctx; } } } // not found, create new if (!owner.reuseTypecheckingContext()) { assert createIfAbsent; final NonReusableTypecheckingContextHolder contextHolder = new NonReusableTypecheckingContextHolder(owner); contextWithOwners.add(contextHolder); return contextHolder.acquire(node); } else if (!createIfAbsent) { return null; } else { if (contextWithOwners.size() > 100) { if (!myReported) { myReported = true; LOG.warn( "Type checking context for node " + node.getPresentation() + " has too much owners"); } } final CountingTypecheckingContextHolder contextHolder = new CountingTypecheckingContextHolder(owner); contextWithOwners.add(contextHolder); return contextHolder.acquire(node); } } }
public TypeCheckingContext createTracingTypeCheckingContext(SNode node) { ModelAccess.assertLegalRead(); return new TracingTypecheckingContext(node, myTypeChecker); }