public void execute(final SNode node, final EditorContext editorContext) { String name = CreateFromUsageUtil.getText(editorContext); if (name == null || name.length() == 0) { name = "default_" + SPropertyOperations.getString(node, "name"); } SNode t = SNodeFactoryOperations.createNewRootNode( SNodeOperations.getModel(node), "jetbrains.mps.lang.generator.structure.TemplateDeclaration", null); SPropertyOperations.set(t, "name", name); t.setProperty( SModelTreeNode.PACK, SPropertyOperations.getString( SNodeOperations.cast( SNodeOperations.getContainingRoot(node), "jetbrains.mps.lang.core.structure.BaseConcept"), "virtualPackage")); // make reference SNode tr = SNodeFactoryOperations.createNewNode( "jetbrains.mps.lang.generator.structure.TemplateDeclarationReference", null); SLinkOperations.setTarget(tr, "template", t, false); SLinkOperations.setTarget(node, "defaultConsequence", tr, true); }
public void execute(final SNode node, final EditorContext editorContext) { SNode templateNode = SNodeFactoryOperations.createNewRootNode( SNodeOperations.getModel(node), "jetbrains.mps.lang.generator.structure.TemplateDeclaration", null); SNode ruleNode = SNodeOperations.getAncestor( node, "jetbrains.mps.lang.generator.structure.BaseMappingRule", false, false); SLinkOperations.setTarget( templateNode, "applicableConcept", SLinkOperations.getTarget(ruleNode, "applicableConcept", false), false); SPropertyOperations.set(templateNode, "name", "template1"); SLinkOperations.setTarget( templateNode, "contentNode", SLinkOperations.getTarget(node, "templateNode", true), true); SPropertyOperations.set( templateNode, "virtualPackage", SPropertyOperations.getString(SNodeOperations.getContainingRoot(node), "virtualPackage")); SNode templateRefNode = SNodeFactoryOperations.replaceWithNewChild( node, "jetbrains.mps.lang.generator.structure.TemplateDeclarationReference"); SLinkOperations.setTarget(templateRefNode, "template", templateNode, false); SelectionUtil.selectNode(editorContext, templateNode); }
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); }
private static void attachReference_id2wBFdLy8qmn(@NotNull SNode __thisNode__, SNode reference) { assert IReferenceAttachable_BehaviorDescriptor.canAttachReference_id2wBFdLy7HtS.invoke( __thisNode__, reference); SLinkOperations.setTarget( __thisNode__, MetaAdapterFactory.getContainmentLink( 0x8585453e6bfb4d80L, 0x98deb16074f1d86cL, 0x73a7cdcfbbbf8aadL, 0x73a7cdcfbbbf8c41L, "warningRef"), SConceptOperations.createNewNode( SNodeOperations.asInstanceConcept( MetaAdapterFactory.getConcept( 0x8585453e6bfb4d80L, 0x98deb16074f1d86cL, 0x6abc06f5f4af0d67L, "jetbrains.mps.lang.test.structure.UnknownRuleReference")))); SLinkOperations.setTarget( SLinkOperations.getTarget( __thisNode__, MetaAdapterFactory.getContainmentLink( 0x8585453e6bfb4d80L, 0x98deb16074f1d86cL, 0x73a7cdcfbbbf8aadL, 0x73a7cdcfbbbf8c41L, "warningRef")), MetaAdapterFactory.getReferenceLink( 0x8585453e6bfb4d80L, 0x98deb16074f1d86cL, 0x6abc06f5f4afab9dL, 0x73a7cdcfba51f755L, "declaration"), reference); }
public static void nodeFactory_NodeSetup_TypeOfExpression_1179476271704( final IOperationContext operationContext, final NodeSetupContext _context) { if (SNodeOperations.isInstanceOf( _context.getSampleNode(), "jetbrains.mps.baseLanguage.structure.Expression")) { if (!(SNodeOperations.isInstanceOf( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.TypeOfExpression"))) { SLinkOperations.setTarget( _context.getNewNode(), "term", SNodeOperations.cast( _context.getSampleNode(), "jetbrains.mps.baseLanguage.structure.Expression"), true); } else { SLinkOperations.setTarget( _context.getNewNode(), "term", SLinkOperations.getTarget( SNodeOperations.cast( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.TypeOfExpression"), "term", true), true); } } }
public static void nodeFactory_NodeSetup_CoerceExpression_1178879020941( final IOperationContext operationContext, final NodeSetupContext _context) { if (SNodeOperations.isInstanceOf( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.CoerceExpression")) { SLinkOperations.setTarget( _context.getNewNode(), "nodeToCoerce", SLinkOperations.getTarget( SNodeOperations.cast( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.CoerceExpression"), "nodeToCoerce", true), true); SLinkOperations.setTarget( _context.getNewNode(), "pattern", SLinkOperations.getTarget( SNodeOperations.cast( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.CoerceExpression"), "pattern", true), true); } }
public SNode convertField(PsiField x, SNode parentConcept) { SNode field; if (isStatic(x) || SConceptOperations.isSubConceptOf( parentConcept, "jetbrains.mps.baseLanguage.structure.Interface")) { field = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.StaticFieldDeclaration", null); } else { field = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.FieldDeclaration", null); SPropertyOperations.set( SNodeOperations.cast(field, "jetbrains.mps.baseLanguage.structure.FieldDeclaration"), "isVolatile", "" + (x.hasModifierProperty(PsiModifier.VOLATILE))); SPropertyOperations.set( SNodeOperations.cast(field, "jetbrains.mps.baseLanguage.structure.FieldDeclaration"), "isTransient", "" + (x.hasModifierProperty(PsiModifier.TRANSIENT))); } SPropertyOperations.set(field, "name", x.getName()); SLinkOperations.setTarget( SNodeOperations.cast(field, "jetbrains.mps.baseLanguage.structure.ClassifierMember"), "visibility", getVisibility(x), true); SPropertyOperations.set(field, "isFinal", "" + (isFinal(x))); SLinkOperations.setTarget(field, "type", convertType(x.getType()), true); addAnnotations(x, field); return field; }
public static void nodeFactory_NodeSetup_IsSubtypeExpression_1177408248540( final IOperationContext operationContext, final NodeSetupContext _context) { if (SNodeOperations.isInstanceOf( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.IsSubtypeExpression")) { SLinkOperations.setTarget( _context.getNewNode(), "subtypeExpression", SLinkOperations.getTarget( SNodeOperations.cast( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.IsSubtypeExpression"), "subtypeExpression", true), true); SLinkOperations.setTarget( _context.getNewNode(), "supertypeExpression", SLinkOperations.getTarget( SNodeOperations.cast( _context.getSampleNode(), "jetbrains.mps.lang.typesystem.structure.IsSubtypeExpression"), "supertypeExpression", true), true); } }
public static void nodeFactory_NodeSetup_CBinaryOp_6585869519574724396( final IOperationContext operationContext, final NodeSetupContext _context) { if (SNodeOperations.isInstanceOf( _context.getSampleNode(), "jetbrains.mps.nanoc.structure.CBinaryOp")) { SNode binaryOp = SNodeOperations.cast(_context.getSampleNode(), "jetbrains.mps.nanoc.structure.CBinaryOp"); SLinkOperations.setTarget( _context.getNewNode(), "left", SLinkOperations.getTarget(binaryOp, "left", true), true); SLinkOperations.setTarget( _context.getNewNode(), "right", SLinkOperations.getTarget(binaryOp, "right", true), true); } }
public SNode getSubOrSuperType( SNode xmlType, TypeCheckingContext typeCheckingContext, IsApplicableStatus status) { if ((SLinkOperations.getTarget(xmlType, "schema", false) == null)) { return _quotation_createNode_vusj77_a0a0a0(); } else { for (SNode te : ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget( SLinkOperations.getTarget(xmlType, "complexType", false), "typeExpressionList", true), "typeExpression", true))) { if (SNodeOperations.isInstanceOf(te, "jetbrains.mps.xmlSchema.structure.ComplexContent")) { if (SNodeOperations.isInstanceOf( SLinkOperations.getTarget( SNodeOperations.cast(te, "jetbrains.mps.xmlSchema.structure.ComplexContent"), "contentItem", true), "jetbrains.mps.xmlSchema.structure.Extension")) { SNode ct = SLinkOperations.getTarget( SLinkOperations.getTarget( SLinkOperations.getTarget( SNodeOperations.cast( te, "jetbrains.mps.xmlSchema.structure.ComplexContent"), "contentItem", true), "complexTypeReference", true), "complexType", false); SNode type = SConceptOperations.createNewNode( "jetbrains.mps.xmlQuery.structure.XMLElementType", null); SLinkOperations.setTarget( type, "schema", SNodeOperations.getAncestor( ct, "jetbrains.mps.xmlSchema.structure.Schema", false, false), false); SLinkOperations.setTarget(type, "complexType", ct, false); return type; } } } return _quotation_createNode_vusj77_a1a0a0a(); } }
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 void init(SNode thisNode) { SLinkOperations.setTarget( thisNode, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x112670d273fL, 0x112670d886aL, "visibility"), _quotation_createNode_fkmlyr_a0a0a()); }
@Override public void execute(@NotNull String pattern) { final SNode result = SNodeFactoryOperations.createNewNode( SNodeFactoryOperations.asInstanceConcept( MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x11adecdb4f0L, "jetbrains.mps.baseLanguage.structure.PostfixIncrementExpression")), null); SLinkOperations.setTarget( result, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x120a4c1f269L, 0x120a4c433a6L, "expression"), SNodeOperations.copyNode(_context.getNode())); SNodeOperations.replaceWithAnother(_context.getNode(), result); SelectionUtil.selectLabelCellAnSetCaret( _context.getEditorContext(), result, SelectionManager.LAST_CELL, -1); return; }
public SNode createMethodCall(SNode declaration, List<SNode> parameters) { if (SNodeOperations.isInstanceOf( declaration, "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration")) { SNode result = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.DotExpression", null); SLinkOperations.setTarget( result, "operand", SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.ThisExpression", null), true); SNode callOperation = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.InstanceMethodCallOperation", null); SLinkOperations.setTarget(result, "operation", callOperation, true); SLinkOperations.setTarget( callOperation, "baseMethodDeclaration", SNodeOperations.cast( declaration, "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration"), false); ListSequence.fromList(SLinkOperations.getTargets(callOperation, "actualArgument", true)) .addSequence(ListSequence.fromList(parameters)); return result; } else { SNode call = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.StaticMethodCall", null); SLinkOperations.setTarget( call, "classConcept", SNodeOperations.cast( SNodeOperations.getParent(declaration), "jetbrains.mps.baseLanguage.structure.ClassConcept"), false); SLinkOperations.setTarget( call, "baseMethodDeclaration", SNodeOperations.cast( declaration, "jetbrains.mps.baseLanguage.structure.StaticMethodDeclaration"), false); ListSequence.fromList(SLinkOperations.getTargets(call, "actualArgument", true)) .addSequence(ListSequence.fromList(parameters)); return call; } }
public void execute(final SNode node, final EditorContext editorContext) { SLinkOperations.setTarget( node, "handler", SNodeFactoryOperations.createNewNode( "jetbrains.mps.core.xml.sax.structure.XMLSAXAttributeHandler", null), true); }
private void addEnum(SNode attrDecl, String[] enumValues) { if (enumValues == null) { return; } SNode senum = _quotation_createNode_ixz87t_a0b0j9(); this.updateEnum(senum, enumValues); SLinkOperations.setTarget(attrDecl, "enum", senum, true); }
public void execute_internal(EditorContext editorContext, SNode node) { SLinkOperations.setTarget( node, "removeHints", SConceptOperations.createNewNode( "jetbrains.mps.lang.editor.structure.ExplicitHintsSpecification", null), true); }
private SNode convert(Dependency source) { SNode dep = SModelOperations.createNewNode( myModel, "jetbrains.mps.lang.project.structure.ModuleDependency", null); SPropertyOperations.set(dep, "reexport", "" + source.isReexport()); SLinkOperations.setTarget(dep, "moduleRef", convert(source.getModuleRef()), true); return dep; }
public static SNode getBinaryOperationType(SNode leftType, SNode rightType, boolean mayBeString) { List<SNode> leastCommonSupertypes = SubtypingUtil.leastCommonSuperTypes(Arrays.asList(leftType, rightType), null); if (mayBeString) { SModel javaLangJavaStubModelDescriptor = SModelRepository.getInstance() .getModelDescriptor(SModelReference.fromString("java.lang@java_stub")); assert javaLangJavaStubModelDescriptor != null; SModel javaLang = javaLangJavaStubModelDescriptor.getSModel(); SNode stringClass = SModelOperations.getRootByName(javaLang, "String"); if (SNodeOperations.isInstanceOf( leftType, "jetbrains.mps.baseLanguage.structure.ClassifierType") && SLinkOperations.getTarget( (SNodeOperations.cast( leftType, "jetbrains.mps.baseLanguage.structure.ClassifierType")), "classifier", false) == stringClass || SNodeOperations.isInstanceOf( rightType, "jetbrains.mps.baseLanguage.structure.ClassifierType") && SLinkOperations.getTarget( (SNodeOperations.cast( rightType, "jetbrains.mps.baseLanguage.structure.ClassifierType")), "classifier", false) == stringClass) { SNode classifierType = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.ClassifierType", null); SLinkOperations.setTarget( classifierType, "classifier", SNodeOperations.cast(stringClass, "jetbrains.mps.baseLanguage.structure.Classifier"), false); return classifierType; } } if (leastCommonSupertypes.isEmpty()) { SNode runtimeErrorType = SConceptOperations.createNewNode( "jetbrains.mps.lang.typesystem.structure.RuntimeErrorType", null); SPropertyOperations.set(runtimeErrorType, "errorText", "incompatible types"); return runtimeErrorType; } SNode type = leastCommonSupertypes.iterator().next(); { IMatchingPattern pattern_j6k1pf_e0c = HUtil.createMatchingPatternByConceptFQName( "jetbrains.mps.baseLanguage.structure.PrimitiveType"); SNode coercedNode_j6k1pf_e0c = TypeChecker.getInstance().getRuntimeSupport().coerce_(type, pattern_j6k1pf_e0c); if (coercedNode_j6k1pf_e0c != null) { return coercedNode_j6k1pf_e0c; } else { return type; } } }
public void execute(final SNode node, final EditorContext editorContext) { List<SNode> configs = SModelOperations.getRoots( SNodeOperations.getModel(node), "jetbrains.mps.lang.generator.structure.MappingConfiguration"); if (ListSequence.fromList(configs).count() > 1) { Iterable<SNode> sameVPackConfigs = ListSequence.fromList(configs) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return Comparing.equal( SPropertyOperations.getString(it, "virtualPackage"), SPropertyOperations.getString(node, "virtualPackage")); } }); if (Sequence.fromIterable(sameVPackConfigs).isNotEmpty()) { configs = Sequence.fromIterable(sameVPackConfigs).toListSequence(); } } if (ListSequence.fromList(configs).count() > 1) { // TODO: let user to choose mapping config? } // add new rule SNode rule = SNodeFactoryOperations.addNewChild( ListSequence.fromList(configs).first(), "rootMappingRule", "jetbrains.mps.lang.generator.structure.Root_MappingRule"); SLinkOperations.setTarget( rule, "applicableConcept", SLinkOperations.getTarget( AttributeOperations.getAttribute( node, new IAttributeDescriptor.NodeAttribute( "jetbrains.mps.lang.generator.structure.RootTemplateAnnotation")), "applicableConcept", false), false); SLinkOperations.setTarget(rule, "template", node, false); // open in editor NavigationSupport.getInstance() .openNode(editorContext.getOperationContext(), rule, true, true); }
private SNode convert(ModelRoot source) { SNode result = SModelOperations.createNewNode( myModel, "jetbrains.mps.lang.project.structure.ModelRoot", null); SPropertyOperations.set(result, "path", source.getPath()); SPropertyOperations.set(result, "prefix", source.getPrefix()); SLinkOperations.setTarget(result, "manager", convert(source.getManager()), true); return result; }
@Override public void execute(final SNode node, final EditorContext editorContext) { SNode ifFalse = SLinkOperations.getTarget( node, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b217L, 0xfc092b6b76L, "ifFalseStatement")); SLinkOperations.setTarget( node, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b217L, 0xfc092b6b76L, "ifFalseStatement"), null); SNodeFactoryOperations.addNewChild( node, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b217L, 0x118cecf1287L, "elsifClauses"), SNodeFactoryOperations.asInstanceConcept( MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0x118ceceb41aL, "jetbrains.mps.baseLanguage.structure.ElsifClause"))); SLinkOperations.setTarget( node, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b217L, 0xfc092b6b76L, "ifFalseStatement"), ifFalse); }
public SNode execute(final SModule m) { { final SearchScope scope = CommandUtil.createScope(m); QueryExecutionContext context = new QueryExecutionContext() { public SearchScope getDefaultSearchScope() { return scope; } }; Iterable<SNode> cellModels = CollectionSequence.fromCollection( CommandUtil.instances( CommandUtil.createConsoleScope(null, false, context), MetaAdapterFactory.getConcept( 0x18bc659203a64e29L, 0xa83a7ff23bde13baL, 0xf9eb05cdc7L, "jetbrains.mps.lang.editor.structure.CellModel_RefNode"))) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return needToMigrate(it); } }); for (SNode cellModel : Sequence.fromIterable(cellModels)) { SNodeOperations.deleteNode( SLinkOperations.getTarget( cellModel, MetaAdapterFactory.getContainmentLink( 0x18bc659203a64e29L, 0xa83a7ff23bde13baL, 0xf9eafb9a39L, 0x10a19696199L, "renderingCondition"))); SPropertyOperations.set( cellModel, MetaAdapterFactory.getProperty( 0x18bc659203a64e29L, 0xa83a7ff23bde13baL, 0xf9eb05cdc7L, 0x3a4d559b401214L, "customizeEmptyCell"), "" + (true)); SLinkOperations.setTarget( cellModel, MetaAdapterFactory.getContainmentLink( 0x18bc659203a64e29L, 0xa83a7ff23bde13baL, 0xf9eb05cdc7L, 0x3a4d559b42e5cbL, "emptyCellModel"), _quotation_createNode_i6fkmm_a0c0b0a0h()); } } return null; }
public void execute(final SNode node, final EditorContext editorContext) { SNode externalProperty = SNodeFactoryOperations.createNewNode( "jetbrains.mps.buildlanguage.structure.ExternalPropertyDeclaration", null); SLinkOperations.setTarget( externalProperty, "type", SLinkOperations.getTarget(node, "type", true), true); SPropertyOperations.set( externalProperty, "name", SPropertyOperations.getString(node, "name")); SNodeOperations.replaceWithAnother(node, externalProperty); }
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 test_testRotation() throws Exception { this.addNodeById("3852894662483441863"); this.addNodeById("3852894662483449708"); SNode op = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.PlusExpression", null); SNode constant = SConceptOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.IntegerConstant", null); SPropertyOperations.set(constant, "value", "" + (3)); SLinkOperations.setTarget(op, "leftExpression", constant, true); SNodeOperations.replaceWithAnother( SNodeOperations.cast( this.getNodeById("3852894662483449704"), "jetbrains.mps.baseLanguage.structure.PlusExpression"), op); SLinkOperations.setTarget( op, "rightExpression", SNodeOperations.cast( this.getNodeById("3852894662483449704"), "jetbrains.mps.baseLanguage.structure.PlusExpression"), true); ParenthesisUtil.checkOperationWRTPriority(op); { List<SNode> nodesBefore = ListSequence.fromListAndArray( new ArrayList<SNode>(), SNodeOperations.cast( this.getNodeById("3852894662483449711"), "jetbrains.mps.baseLanguage.structure.ExpressionStatement")); List<SNode> nodesAfter = ListSequence.fromListAndArray( new ArrayList<SNode>(), SNodeOperations.cast( this.getNodeById("3852894662483449702"), "jetbrains.mps.baseLanguage.structure.ExpressionStatement")); Assert.assertNull( "nodes '" + nodesBefore + "' and '" + nodesAfter + "' do not match!", NodesMatcher.matchNodes(nodesBefore, nodesAfter)); } }
public void execute(final SNode node, final EditorContext editorContext) { SNode castVariable = SNodeFactoryOperations.createNewNode( "jetbrains.mps.baseLanguage.structure.LocalVariableDeclarationStatement", null); SNode instanceOfExpression = SNodeOperations.cast( SLinkOperations.getTarget(node, "condition", true), "jetbrains.mps.baseLanguage.structure.InstanceOfExpression"); SNode declaration = SLinkOperations.getTarget(castVariable, "localVariableDeclaration", true); SLinkOperations.setTarget( declaration, "type", SNodeOperations.copyNode( SLinkOperations.getTarget(instanceOfExpression, "classType", true)), true); List<String> variableSuffixes = BehaviorReflection.invokeVirtual( (Class<List<String>>) ((Class) Object.class), SLinkOperations.getTarget(instanceOfExpression, "classType", true), "virtual_getVariableSuffixes_1213877337304", new Object[] {}); SPropertyOperations.set(declaration, "name", ListSequence.fromList(variableSuffixes).first()); SNode castExpression = SNodeFactoryOperations.setNewChild( declaration, "initializer", "jetbrains.mps.baseLanguage.structure.CastExpression"); SLinkOperations.setTarget( castExpression, "type", SNodeOperations.copyNode( SLinkOperations.getTarget(instanceOfExpression, "classType", true)), true); SLinkOperations.setTarget( castExpression, "expression", SNodeOperations.copyNode( SLinkOperations.getTarget(instanceOfExpression, "leftExpression", true)), true); ListSequence.fromList( SLinkOperations.getTargets( SLinkOperations.getTarget(node, "ifTrue", true), "statement", true)) .insertElement(0, castVariable); }
public void execute(final SNode node, final EditorContext editorContext) { SNode executor = SNodeFactoryOperations.createNewNode( "jetbrains.mps.execution.configurations.structure.RunConfigurationExecutor", null); SLinkOperations.setTarget(executor, "configuration", node, false); SPropertyOperations.set( executor, "virtualPackage", SPropertyOperations.getString(node, "virtualPackage")); SModelOperations.addRootNode(SNodeOperations.getModel(node), executor); NavigationSupport.getInstance() .openNode(editorContext.getOperationContext(), executor, true, false); }
public static SNode virtual_getType_228266671027861783(SNode thisNode) { SNode listType = SConceptOperations.createNewNode( "jetbrains.mps.core.query.structure.MqlOrderedSetType", null); SLinkOperations.setTarget( listType, "inner", SNodeOperations.copyNode(SLinkOperations.getTarget(thisNode, "elementType", true)), true); return listType; }
/*package*/ static void setTarget_id1xCtdgeUoP5(@NotNull SNode __thisNode__, SNode target) { SLinkOperations.setTarget( __thisNode__, MetaAdapterFactory.getReferenceLink( 0xd7706f639be2479cL, 0xa3daae92af1e64d5L, 0x3fb2d847d55fc21eL, 0x3fb2d847d55fdcd5L, "patternVarDecl"), null); }