public void applyRule( final SNode classifier, final TypeCheckingContext typeCheckingContext, IsApplicableStatus status) { OverridingMethodsFinder finder = new OverridingMethodsFinder(classifier); Set<SNode> overridingMethods = finder.getOverridingMethods(); for (SNode method : SLinkOperations.getTargets(classifier, "method", true)) { for (SNode annotationInstance : SLinkOperations.getTargets(method, "annotation", true)) { if (SLinkOperations.getTarget(annotationInstance, "annotation", false) == SNodeOperations.getNode( "f:java_stub#6354ebe7-c22a-4a0f-ac54-50b52ab9b065#java.lang(JDK/java.lang@java_stub)", "~Override") && !(SetSequence.fromSet(overridingMethods).contains(method))) { { MessageTarget errorTarget = new NodeMessageTarget(); IErrorReporter _reporter_2309309498 = typeCheckingContext.reportTypeError( annotationInstance, "Method does not override method from its superclass", "r:00000000-0000-4000-0000-011c895902c5(jetbrains.mps.baseLanguage.typesystem)", "4540477783368646804", null, errorTarget); } break; } } } }
public static boolean virtual_isMpsStartRequired_3310779261129403089(SNode thisNode) { for (SNode annotationInstance : ListSequence.fromList(SLinkOperations.getTargets(thisNode, "annotation", true))) { if (SLinkOperations.getTarget(annotationInstance, "annotation", false) .equals( SNodeOperations.getNode( "f:java_stub#920eaa0e-ecca-46bc-bee7-4e5c59213dd6#jetbrains.mps(Testbench/jetbrains.mps@java_stub)", "~MPSLaunch"))) { return true; } } for (SNode method : SLinkOperations.getTargets( SLinkOperations.getTarget(thisNode, "testMethodList", true), "testMethod", true)) { for (SNode annotationInstance : SLinkOperations.getTargets(method, "annotation", true)) { if (SLinkOperations.getTarget(annotationInstance, "annotation", false) .equals( SNodeOperations.getNode( "f:java_stub#920eaa0e-ecca-46bc-bee7-4e5c59213dd6#jetbrains.mps(Testbench/jetbrains.mps@java_stub)", "~MPSLaunch"))) { return true; } } } return false; }
public void synchronize() { Set<SNode> existingBlocks = new HashSet<SNode>(myBlocks); ListIterator<SNode> blocksIterator = myBlocks.listIterator(); Set<SNode> existingConnectors = new HashSet<SNode>(myConnectors); ListIterator<SNode> connectorsIterator = myConnectors.listIterator(); syncDiagramElements( SLinkOperations.getTargets(getSNode(), "component", true), blocksIterator, existingBlocks, connectorsIterator, existingConnectors); syncDiagramElements( ListSequence.fromList(SLinkOperations.getTargets(getSNode(), "component", true)) .translate( new ITranslator2<SNode, SNode>() { public Iterable<SNode> translate(SNode it) { return SLinkOperations.getTargets(it, "dep", true); } }), blocksIterator, existingBlocks, connectorsIterator, existingConnectors); purgeTailNodes(blocksIterator); purgeTailNodes(connectorsIterator); }
public static SNode virtual_getCreatorExpression_7057666463730727863( SNode thisNode, SNode parentRef) { SNode result = SNodeOperations.copyNode( SLinkOperations.getTarget( SLinkOperations.getTarget(thisNode, "declaration", false), "creator", true)); List<SNode> params = SLinkOperations.getTargets( SLinkOperations.getTarget(thisNode, "declaration", false), "parameter", true); List<SNode> args = SLinkOperations.getTargets(thisNode, "argument", true); if (ListSequence.fromList(params).count() != ListSequence.fromList(args).count()) { throw new RuntimeException(); } for (SNode ref : SNodeOperations.getDescendants( result, "jetbrains.mps.baseLanguage.builders.structure.SimpleBuilderParameterReference", false, new String[] {})) { int index = ListSequence.fromList(params).indexOf(SLinkOperations.getTarget(ref, "parameter", false)); SNodeOperations.replaceWithAnother( ref, SNodeOperations.copyNode(ListSequence.fromList(args).getElement(index))); } return result; }
public Set<? extends IVertex> getNexts() { if (targets == null) { if (ListSequence.fromList(SLinkOperations.getTargets(module, "dependencies", true)) .isEmpty()) { targets = Collections.emptySet(); } else { targets = new HashSet<CycleHelper.Module>(); for (SNode ref : ListSequence.fromList(SLinkOperations.getTargets(module, "dependencies", true)) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return SNodeOperations.isInstanceOf( it, "jetbrains.mps.build.workflow.structure.BwfJavaModuleReference"); } })) { CycleHelper.Module tm = map.get( SLinkOperations.getTarget( SNodeOperations.cast( ref, "jetbrains.mps.build.workflow.structure.BwfJavaModuleReference"), "target", false)); if (tm == null) { genContext.showErrorMessage(ref, "internal problem: unsatisfied local dependency"); } else { targets.add(tm); } } } } return targets; }
public void doGenerateText(SNode node) { if (getBuffer().hasPositionsSupport()) { TraceInfoGenerationUtil.createPositionInfo(this, node); } for (SNode item : SLinkOperations.getTargets(node, "item", true)) { if (item != ListSequence.fromList(SLinkOperations.getTargets(node, "item", true)).first()) { TextGenManager.instance() .appendNodeText( this.getContext(), this.getBuffer(), SLinkOperations.getTarget(node, "separator", true), this.getSNode()); } TextGenManager.instance() .appendNodeText(this.getContext(), this.getBuffer(), item, this.getSNode()); } if (getBuffer().hasPositionsSupport()) { { String traceableProperty = ""; try { traceableProperty = BehaviorReflection.invokeVirtual( String.class, SNodeOperations.cast( node, "jetbrains.mps.lang.traceable.structure.TraceableConcept"), "virtual_getTraceableProperty_5067982036267369901", new Object[] {}); } catch (Throwable t) { LOG.error("Can't calculate traceable prorerty for a node " + node + ".", t); } TraceInfoGenerationUtil.fillPositionInfo(this, node, traceableProperty); } } }
public static Object insertMacro_varValue_3961775458390375615( final TemplateQueryContext _context) { StringBuilder res = new StringBuilder(); Set<String> used = new HashSet<String>(); Iterable<SNode> dependencies = SLinkOperations.getTargets(_context.getNode(), "dependencies", true); for (SNode part : ((List<SNode>) _context.getVariable("var:taskParts"))) { dependencies = Sequence.fromIterable(dependencies) .concat( ListSequence.fromList( SLinkOperations.getTargets(part, "additionalDependencies", true))); } for (SNode dep : dependencies) { String d = SPropertyOperations.getString(SLinkOperations.getTarget(dep, "target", false), "name"); if (used.add(d)) { if (res.length() > 0) { res.append(", "); } res.append(d); } } return res.toString(); }
@Override public void addNested(SNode decl, final SNode nestedDecl, ClassInfo.Nested nested) { SNode node = ListSequence.fromList(SLinkOperations.getTargets(decl, "nested", true)) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return eq_ixz87t_a0a0a0a0a0a0a0l9( SLinkOperations.getTarget(it, "declaration", false), nestedDecl); } }) .first(); if ((node != null)) { for (String name : nested.getNames()) { this.addNestedName(decl, node, name); } return; } SNode nref = _quotation_createNode_ixz87t_a0d0l9(nestedDecl); if (eq_ixz87t_a0e0l9(SLinkOperations.getTarget(nref, "declaration", false), nestedDecl)) { for (String name : nested.getNames()) { this.addNestedName(decl, nref, name); } } ListSequence.fromList(SLinkOperations.getTargets(decl, "nested", true)).addElement(nref); }
public void applyRule( final SNode annotationInstance, final TypeCheckingContext typeCheckingContext, IsApplicableStatus status) { SNode annotation = SLinkOperations.getTarget(annotationInstance, "annotation", false); for (SNode annotationMethod : SLinkOperations.getTargets(annotation, "method", true)) { if ((SLinkOperations.getTarget(annotationMethod, "defaultValue", true) != null)) { continue; } boolean found = false; for (SNode annotationInstanceValue : SLinkOperations.getTargets(annotationInstance, "value", true)) { if (SLinkOperations.getTarget(annotationInstanceValue, "key", false) == annotationMethod) { found = true; break; } } if (!(found)) { { MessageTarget errorTarget = new NodeMessageTarget(); IErrorReporter _reporter_2309309498 = typeCheckingContext.reportTypeError( annotationInstance, "'" + SPropertyOperations.getString(annotationMethod, "name") + "' missing though required", "r:00000000-0000-4000-0000-011c895902c5(jetbrains.mps.baseLanguage.typesystem)", "6624237184121162632", null, errorTarget); } } } }
public void build( final IOperationContext operationContext, final DataFlowBuilderContext _context) { _context .getBuilder() .build((SNode) SLinkOperations.getTarget(_context.getNode(), "leftExpression", true)); _context .getBuilder() .build((SNode) SLinkOperations.getTarget(_context.getNode(), "rightExpression", true)); if ((SLinkOperations.getTarget(_context.getNode(), "errorString", true) != null)) { _context .getBuilder() .build((SNode) SLinkOperations.getTarget(_context.getNode(), "errorString", true)); } if ((SLinkOperations.getTarget(_context.getNode(), "nodeToCheck", true) != null)) { _context .getBuilder() .build((SNode) SLinkOperations.getTarget(_context.getNode(), "nodeToCheck", true)); } if (ListSequence.fromList( SLinkOperations.getTargets(_context.getNode(), "helginsIntention", true)) .isNotEmpty()) { for (SNode intetntion : SLinkOperations.getTargets(_context.getNode(), "helginsIntention", true)) { _context.getBuilder().build((SNode) intetntion); } } }
private boolean isApplicableToNode(final SNode node, final EditorContext editorContext) { Iterable<SNode> nodes = ListSequence.fromList(SNodeOperations.getChildren(SNodeOperations.getParent(node))) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return SNodeOperations.isInstanceOf( it, "jetbrains.mps.lang.generator.structure.NodeMacro"); } }); boolean seen = false; for (SNode n : nodes) { if (seen) { if (SNodeOperations.isInstanceOf( n, "jetbrains.mps.lang.generator.structure.CopySrcNodeMacro")) { SNode m = SLinkOperations.getTarget( SNodeOperations.cast( n, "jetbrains.mps.lang.generator.structure.CopySrcNodeMacro"), "sourceNodeQuery", true); if ((m == null) || (SLinkOperations.getTarget(m, "body", true) == null) || ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(m, "body", true), "statement", true)) .isEmpty() || ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(m, "body", true), "statement", true)) .count() > 1) { return false; } SNode st = ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(m, "body", true), "statement", true)) .first(); return SNodeOperations.isInstanceOf( st, "jetbrains.mps.baseLanguage.structure.ExpressionStatement") && SNodeOperations.isInstanceOf( SLinkOperations.getTarget( SNodeOperations.cast( st, "jetbrains.mps.baseLanguage.structure.ExpressionStatement"), "expression", true), "jetbrains.mps.lang.generator.structure.TemplateFunctionParameter_sourceNode"); } else { return false; } } else if (n == node) { seen = true; } } return false; }
public static List<SNode> call_getAllSuperClassifiers_4892662966716545618(SNode thisNode) { Set<SNode> seen = SetSequence.fromSet(new HashSet<SNode>()); List<SNode> result = new ArrayList<SNode>(); Queue<SNode> q = QueueSequence.fromQueue(new LinkedList<SNode>()); QueueSequence.fromQueue(q).addLastElement(thisNode); while (QueueSequence.fromQueue(q).isNotEmpty()) { SNode qn = QueueSequence.fromQueue(q).removeFirstElement(); ListSequence.fromList(result).addElement(qn); if (SNodeOperations.isInstanceOf(qn, "jetbrains.mps.baseLanguage.structure.ClassConcept")) { if ((SLinkOperations.getTarget( SNodeOperations.cast(qn, "jetbrains.mps.baseLanguage.structure.ClassConcept"), "superclass", true) != null)) { SNode cl = SLinkOperations.getTarget( SLinkOperations.getTarget( SNodeOperations.cast(qn, "jetbrains.mps.baseLanguage.structure.ClassConcept"), "superclass", true), "classifier", false); if (seen.add(cl)) { QueueSequence.fromQueue(q).addLastElement(cl); } } for (SNode i : SLinkOperations.getTargets( SNodeOperations.cast(qn, "jetbrains.mps.baseLanguage.structure.ClassConcept"), "implementedInterface", true)) { SNode cl = SLinkOperations.getTarget(i, "classifier", false); if (seen.add(cl)) { QueueSequence.fromQueue(q).addLastElement(cl); } } } else if (SNodeOperations.isInstanceOf( qn, "jetbrains.mps.baseLanguage.structure.Interface")) { for (SNode i : SLinkOperations.getTargets( SNodeOperations.cast(qn, "jetbrains.mps.baseLanguage.structure.Interface"), "extendedInterface", true)) { SNode cl = SLinkOperations.getTarget(i, "classifier", false); if (seen.add(cl)) { QueueSequence.fromQueue(q).addLastElement(cl); } } } } SNode obj = _quotation_createNode_xjj00_a0f0m(); if (seen.add(SLinkOperations.getTarget(obj, "classifier", false))) { ListSequence.fromList(result).addElement(SLinkOperations.getTarget(obj, "classifier", false)); } return result; }
private static boolean renderingCondition_1xd1xh_a0a( SNode node, EditorContext editorContext, IScope scope) { return ListSequence.fromList(SLinkOperations.getTargets(node, "actualArgument", true)) .isNotEmpty() || (SLinkOperations.getTarget(node, "template", false) != null) && ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(node, "template", false), "parameter", true)) .isNotEmpty(); }
private void addNestedName(SNode declaration, SNode nref, String name) { for (SNode ref : SLinkOperations.getTargets(nref, "role", true)) { if (eq_ixz87t_a0a0a0m9( SPropertyOperations.getString( SLinkOperations.getTarget(ref, "declaration", false), "name"), name)) { return; } } if (eq_ixz87t_a0c0m9( SPropertyOperations.getString( SLinkOperations.getTarget(nref, "declaration", false), "name"), name)) { ListSequence.fromList(SLinkOperations.getTargets(nref, "role", true)) .addElement( Generator.GENERATOR.createDeclarationReference( SNodeOperations.cast( SLinkOperations.getTarget(nref, "declaration", false), "jetbrains.mps.build.generictasks.structure.BuiltInTaskDeclaration"))); return; } SNode parentDeclaration = SNodeOperations.cast( SLinkOperations.getTarget(nref, "declaration", false), "jetbrains.mps.build.generictasks.structure.BuiltInTaskDeclaration"); SNode parentRef = Generator.GENERATOR.createDeclarationReference(parentDeclaration); SNode fake; if (SNodeOperations.isInstanceOf( parentDeclaration, "jetbrains.mps.build.generictasks.structure.TaskInterfaceDeclaration")) { fake = Generator.GENERATOR.createInterfaceDeclaration( name, SPropertyOperations.getString(parentDeclaration, "classname"), SPropertyOperations.getBoolean(parentDeclaration, "depracated")); ListSequence.fromList(SLinkOperations.getTargets(fake, "interfaces", true)) .addElement(parentRef); } else { fake = Generator.GENERATOR.createDeclaration( name, SPropertyOperations.getString(parentDeclaration, "classname"), SPropertyOperations.getBoolean(parentDeclaration, "abstract"), SPropertyOperations.getBoolean(parentDeclaration, "canHaveInternalText"), SPropertyOperations.getBoolean(parentDeclaration, "depracated")); SLinkOperations.setTarget(fake, "parentRef", parentRef, true); } SPropertyOperations.set(fake, "fake", "" + (true)); ListSequence.fromList(SLinkOperations.getTargets(nref, "role", true)) .addElement(Generator.GENERATOR.createDeclarationReference(fake)); ListSequence.fromList(SLinkOperations.getTargets(declaration, "fakeDeclaration", true)) .addElement(fake); }
public void performActions(Program o, SNode node) { SNode m = node; SNode targetNode = node; while (SNodeOperations.isInstanceOf( SNodeOperations.getParent(targetNode), "jetbrains.mps.baseLanguage.structure.DotExpression") && SLinkOperations.getTarget( SNodeOperations.cast( SNodeOperations.getParent(targetNode), "jetbrains.mps.baseLanguage.structure.DotExpression"), "operation", true) == targetNode) { targetNode = SNodeOperations.getParent(targetNode); } if (SLinkOperations.getTargets( SLinkOperations.getTarget(m, "baseMethodDeclaration", false), "annotation", true) != null) { for (SNode annotation : SLinkOperations.getTargets( SLinkOperations.getTarget(m, "baseMethodDeclaration", false), "annotation", true)) { if (SLinkOperations.getTarget(annotation, "annotation", false) == SNodeOperations.getNode( "f:java_stub#3f233e7f-b8a6-46d2-a57f-795d56775243#org.jetbrains.annotations(Annotations/org.jetbrains.annotations@java_stub)", "~Nullable")) { { Object object = node; if (((Program) o).contains(object)) { boolean before = false; int position = ((Program) (o)).getEnd(object); Instruction instruction = new nullableInstruction(targetNode); instruction.setSource(node); ((Program) (o)).insert(instruction, position, true, before); } } } if (SLinkOperations.getTarget(annotation, "annotation", false) == SNodeOperations.getNode( "f:java_stub#3f233e7f-b8a6-46d2-a57f-795d56775243#org.jetbrains.annotations(Annotations/org.jetbrains.annotations@java_stub)", "~NotNull")) { { Object object = node; if (((Program) o).contains(object)) { boolean before = false; int position = ((Program) (o)).getEnd(object); Instruction instruction = new notNullInstruction(targetNode); instruction.setSource(node); ((Program) (o)).insert(instruction, position, true, before); } } } } } }
public static void innerClassifiers(SNode concept, final SNodeTextGen textGen) { for (SNode classifier : SLinkOperations.getTargets(concept, "staticInnerClassifiers", true)) { TextGenManager.instance() .appendNodeText( textGen.getContext(), textGen.getBuffer(), classifier, textGen.getSNode()); if (!(classifier.equals( ListSequence.fromList(SLinkOperations.getTargets(concept, "staticInnerClassifiers", true)) .last()))) { textGen.appendNewLine(); } } }
public void process() { VisibleArtifacts artifacts = new VisibleArtifacts(project, genContext); artifacts.collect(); UnpackHelper helper = new UnpackHelper(artifacts, genContext); for (SNode dep : SNodeOperations.getDescendants( project, "jetbrains.mps.build.structure.BuildExternalDependency", false, new String[] {})) { BehaviorReflection.invokeVirtual( Void.class, dep, "virtual_fetchDependencies_5908258303322131137", new Object[] { artifacts, new FetchDependenciesProcessor.RequiredDependenciesBuilderImpl(artifacts, dep, helper) }); } helper.eval(); List<SNode> statements = helper.getStatements(); if (!(ListSequence.fromList(statements).isEmpty())) { SNode wf = SModelOperations.createNewNode( SNodeOperations.getModel(project), null, "jetbrains.mps.build.structure.BuildCustomWorkflow"); SNode taskpart = SModelOperations.createNewNode( SNodeOperations.getModel(project), null, "jetbrains.mps.build.workflow.structure.BwfTaskPart"); SLinkOperations.setTarget( taskpart, "task", SLinkOperations.getTarget(_quotation_createNode_t02zqv_a0a2a7a3(), "target", false), false); ListSequence.fromList(SLinkOperations.getTargets(wf, "parts", true)).addElement(taskpart); SNode stask = SModelOperations.createNewNode( SNodeOperations.getModel(project), null, "jetbrains.mps.build.workflow.structure.BwfSubTask"); SPropertyOperations.set(stask, "name", "fetch"); ListSequence.fromList(SLinkOperations.getTargets(taskpart, "subTasks", true)) .addElement(stask); ListSequence.fromList(SLinkOperations.getTargets(stask, "statements", true)) .addSequence(ListSequence.fromList(statements)); ListSequence.fromList(SLinkOperations.getTargets(project, "aspects", true)).addElement(wf); } }
public static Iterable<SNode> sourceNodesQuery_7385586609667799717( final SourceSubstituteMacroNodesContext _context) { List<SNode> subTasks = new ArrayList<SNode>(); ListSequence.fromList(subTasks) .addSequence( ListSequence.fromList( SLinkOperations.getTargets(_context.getNode(), "subTasks", true))); for (SNode part : ((List<SNode>) _context.getVariable("var:taskParts"))) { ListSequence.fromList(subTasks) .addSequence(ListSequence.fromList(SLinkOperations.getTargets(part, "subTasks", true))); } new SubTaskOrderHelper(subTasks, _context).sort(); return subTasks; }
@Override public void addInterface(SNode declaration, SNode interfaceDeclaration) { for (SNode in : SLinkOperations.getTargets(declaration, "interfaces", true)) { if (eq_ixz87t_a0a0a0f9( SPropertyOperations.getString( SLinkOperations.getTarget(in, "declaration", false), "name"), SPropertyOperations.getString(interfaceDeclaration, "name"))) { return; } } SNode ref = Generator.GENERATOR.createDeclarationReference(interfaceDeclaration); ListSequence.fromList(SLinkOperations.getTargets(declaration, "interfaces", true)) .addElement(ref); }
public void synchronize() { super.synchronizeViewWithModel(); myPropertyCell_pj4dhh_a0a.synchronize(); myPropertyCell_pj4dhh_a1a.synchronize(); myPropertyCell_pj4dhh_a2a.synchronize(); myPropertyCell_pj4dhh_a3a.synchronize(); syncPortNodes( SLinkOperations.getTargets(getSNode(), "inputPorts", true), myInputPorts.listIterator(), new HashSet<SNode>(myInputPorts)); syncPortNodes( SLinkOperations.getTargets(getSNode(), "outputPorts", true), myOutputPorts.listIterator(), new HashSet<SNode>(myOutputPorts)); }
public void doGenerateText(SNode node) { TextGenManager.instance() .appendNodeText( this.getContext(), this.getBuffer(), SLinkOperations.getTarget(node, "componentType", true), this.getSNode()); if (ListSequence.fromList(SLinkOperations.getTargets(node, "dimensionExpression", true)) .isNotEmpty()) { for (SNode item : SLinkOperations.getTargets(node, "dimensionExpression", true)) { TextGenManager.instance() .appendNodeText(this.getContext(), this.getBuffer(), item, this.getSNode()); } } }
public void execute(final SNode node, final EditorContext editorContext) { SNode statement = SConceptOperations.createNewNode( "org.jetbrains.mps.samples.IfAndUnless.structure.MyIfStatement", null); SLinkOperations.setTarget( statement, "condition", SLinkOperations.getTarget(node, "condition", true), true); SNode ifBody = SConceptOperations.createNewNode( "org.jetbrains.mps.samples.IfAndUnless.structure.TrueFlow", null); ListSequence.fromList(SLinkOperations.getTargets(ifBody, "statement", true)) .addSequence( ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(node, "ifTrue", true), "statement", true))); SLinkOperations.setTarget(statement, "body", ifBody, true); SLinkOperations.setTarget( statement, "alternative", SConceptOperations.createNewNode( "org.jetbrains.mps.samples.IfAndUnless.structure.FalseFlow", null), true); if (SNodeOperations.isInstanceOf( SLinkOperations.getTarget(node, "ifFalseStatement", true), "jetbrains.mps.baseLanguage.structure.BlockStatement")) { ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(statement, "alternative", true), "statement", true)) .addSequence( ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget( SNodeOperations.cast( SLinkOperations.getTarget(node, "ifFalseStatement", true), "jetbrains.mps.baseLanguage.structure.BlockStatement"), "statements", true), "statement", true))); } else { ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(statement, "alternative", true), "statement", true)) .addElement(SLinkOperations.getTarget(node, "ifFalseStatement", true)); } SNodeOperations.replaceWithAnother(node, statement); editorContext.select(SLinkOperations.getTarget(statement, "condition", true)); }
public static Iterable sourceNodesQuery_2323553266848914918( final IOperationContext operationContext, final SourceSubstituteMacroNodesContext _context) { return ListSequence.fromList( SLinkOperations.getTargets( ((SNode) _context.getVariable("methodDecl")), "parameter", true)) .skip(1); }
public void execute(final SNode node, final EditorContext editorContext) { // produce throw statement SNode throwStatement = SNodeFactoryOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.ThrowStatement", null); SNode newExpr = _quotation_createNode_a1x6vi_a0c0a(); SLinkOperations.setTarget(throwStatement, "throwable", newExpr, true); // produce if statement SNode ifStatement = SNodeFactoryOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.IfStatement", null); SNode notExpr = SNodeFactoryOperations.setNewChild( ifStatement, "condition", "jetbrains.mps.baseLanguage.structure.NotExpression"); SLinkOperations.setTarget( notExpr, "expression", SLinkOperations.getTarget(node, "condition", true), true); SNodeFactoryOperations.setNewChild( ifStatement, "ifTrue", "jetbrains.mps.baseLanguage.structure.StatementList"); ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(ifStatement, "ifTrue", true), "statement", true)) .insertElement(0, throwStatement); // replace assert with if SNodeOperations.replaceWithAnother(node, ifStatement); }
public static boolean baseMappingRule_Condition_2379134940425784781( final IOperationContext operationContext, final BaseMappingRuleContext _context) { boolean methodHasDispatchModifier = SNodeOperations.isInstanceOf( SNodeOperations.getParent(_context.getNode()), "jetbrains.mps.baseLanguage.structure.MethodDeclaration") && ListSequence.fromList( SLinkOperations.getTargets( SNodeOperations.cast( SNodeOperations.getParent(_context.getNode()), "jetbrains.mps.baseLanguage.structure.MethodDeclaration"), "modifiers", true)) .any( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return SNodeOperations.isInstanceOf( it, "jetbrains.mps.baseLanguage.doubleDispatch.structure.DispatchModifier"); } }); return methodHasDispatchModifier && Sequence.fromIterable( DispatchGenUtil.getMatchingMethods( SNodeOperations.cast( SNodeOperations.getParent(_context.getNode()), "jetbrains.mps.baseLanguage.structure.MethodDeclaration"))) .isNotEmpty(); }
public static Object referenceMacro_GetReferent_2323553266849548486( final IOperationContext operationContext, final ReferenceMacroContext _context) { return ListSequence.fromList( SLinkOperations.getTargets( ((SNode) _context.getVariable("methodDecl")), "parameter", true)) .first(); }
private static boolean renderingCondition_arlg9k_a1a( SNode node, EditorContext editorContext, IScope scope) { return ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(node, "baseMethodDeclaration", false), "parameter", true)) .isNotEmpty(); }
public static List<SNode> virtual_getTestMethods_2148145109766218395(SNode thisNode) { List<SNode> result = new ArrayList<SNode>(); if (!(SPropertyOperations.getBoolean(thisNode, "abstractClass"))) { ListSequence.fromList(result) .addSequence( ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(thisNode, "testMethodList", true), "testMethod", true))); if (SNodeOperations.isInstanceOf( SLinkOperations.getTarget( SLinkOperations.getTarget(thisNode, "superclass", true), "classifier", false), "jetbrains.mps.baseLanguage.unitTest.structure.ITestCase")) { ListSequence.fromList(result) .addSequence( ListSequence.fromList( BehaviorReflection.invokeVirtual( (Class<List<SNode>>) ((Class) Object.class), SNodeOperations.cast( SLinkOperations.getTarget( SLinkOperations.getTarget(thisNode, "superclass", true), "classifier", false), "jetbrains.mps.baseLanguage.unitTest.structure.ITestCase"), "virtual_getTestMethods_2148145109766218395", new Object[] {}))); } } return result; }
public void test_RemoveParameter() throws Exception { this.addNodeById("1230052944082"); this.addNodeById("1230052944093"); ChangeMethodSignatureParameters params = new ChangeMethodSignatureParameters( SNodeOperations.cast( this.getNodeById("1230052944084"), "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration")); ListSequence.fromList(SLinkOperations.getTargets(params.getDeclaration(), "parameter", true)) .clear(); ChangeMethodSignatureRefactoring ref = new ChangeMethodSignatureRefactoring( params, SNodeOperations.cast( this.getNodeById("1230052944084"), "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration")); ref.doRefactoring(); { List<SNode> nodesBefore = ListSequence.fromListAndArray( new ArrayList<SNode>(), SNodeOperations.cast( this.getNodeById("1230052944083"), "jetbrains.mps.baseLanguage.structure.ClassConcept")); List<SNode> nodesAfter = ListSequence.fromListAndArray( new ArrayList<SNode>(), SNodeOperations.cast( this.getNodeById("1230052944094"), "jetbrains.mps.baseLanguage.structure.ClassConcept")); Assert.assertNull( "nodes '" + nodesBefore + "' and '" + nodesAfter + "' do not match!", NodesMatcher.matchNodes(nodesBefore, nodesAfter)); } }
public void execute(final SNode node, final EditorContext editorContext) { SNode newLine = SNodeFactoryOperations.createNewNode( "jetbrains.mps.lang.editor.structure.IndentLayoutOnNewLineStyleClassItem", null); SPropertyOperations.set(newLine, "flag", "" + (true)); ListSequence.fromList(SLinkOperations.getTargets(node, "styleItem", true)).addElement(newLine); }