public void execute(final SNode node, final EditorContext editorContext) {
EditorCell selectedCell = editorContext.getSelectedCell();
if (!(selectedCell.isReferenceCell())) {
return;
}
SNode contextNode =
SNodeOperations.cast(
selectedCell.getSNode(), "jetbrains.mps.lang.core.structure.BaseConcept");
if (contextNode == null) {
return;
}
String role = selectedCell.getRole();
if (SNodeOperations.isInstanceOf(
contextNode, "jetbrains.mps.lang.quotation.structure.ReferenceAntiquotation")) {
SNode attributedNode =
SNodeOperations.cast(
SNodeOperations.getParent(contextNode),
"jetbrains.mps.lang.core.structure.BaseConcept");
assert attributedNode != null;
AttributeOperations.setAttribute(
attributedNode,
new IAttributeDescriptor.LinkAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.quotation.structure.ReferenceAntiquotation"),
role),
null);
return;
}
if (AttributeOperations.getAttribute(
contextNode,
new IAttributeDescriptor.LinkAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.quotation.structure.ReferenceAntiquotation"),
role))
!= null) {
AttributeOperations.setAttribute(
contextNode,
new IAttributeDescriptor.LinkAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.quotation.structure.ReferenceAntiquotation"),
role),
null);
} else {
SNode referenceAntiquotation =
SNodeFactoryOperations.setNewAttribute(
contextNode,
new IAttributeDescriptor.LinkAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.quotation.structure.ReferenceAntiquotation"),
role),
"jetbrains.mps.lang.quotation.structure.ReferenceAntiquotation");
if (selectedCell.isSingleNodeCell()) {
SPropertyOperations.set(
referenceAntiquotation,
"label",
SPropertyOperations.getString(
SNodeOperations.getConceptDeclaration(contextNode), "name"));
}
}
}
public static void addVariablePattern(EditorContext context) {
EditorCell contextCell = context.getSelectedCell();
SNode node = contextCell.getSNode();
SNode linkDeclaration =
SNodeOperations.cast(
contextCell.getLinkDeclaration(),
"jetbrains.mps.lang.structure.structure.LinkDeclaration");
SNode genuineLinkDeclaration = SModelUtil.getGenuineLinkDeclaration(linkDeclaration);
if (linkDeclaration != null
&& SPropertyOperations.hasValue(
genuineLinkDeclaration, "metaClass", "reference", "reference")) {
String role = SPropertyOperations.getString(genuineLinkDeclaration, "role");
AttributeOperations.createAndSetAttrbiute(
node,
new IAttributeDescriptor.LinkAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.pattern.structure.LinkPatternVariableDeclaration"),
role),
"jetbrains.mps.lang.pattern.structure.LinkPatternVariableDeclaration");
} else {
AttributeOperations.createAndSetAttrbiute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.pattern.structure.Pattern")),
"jetbrains.mps.lang.pattern.structure.PatternVariableDeclaration");
}
}
public void applyRule(
final SNode nodeToCheck,
final TypeCheckingContext typeCheckingContext,
IsApplicableStatus status) {
SNode linkDeclaration = AttributeOperations.getLinkDeclaration(nodeToCheck);
{
SNode _nodeToCheck_1029348928467 = nodeToCheck;
EquationInfo _info_12389875345 =
new EquationInfo(
_nodeToCheck_1029348928467,
null,
"r:00000000-0000-4000-0000-011c89590343(jetbrains.mps.lang.pattern.typesystem)",
"1202486181555",
0,
null);
typeCheckingContext.createEquation(
(SNode)
typeCheckingContext.typeOf(
_nodeToCheck_1029348928467,
"r:00000000-0000-4000-0000-011c89590343(jetbrains.mps.lang.pattern.typesystem)",
"1202486174317",
true),
(SNode)
_quotation_createNode_onvofq_a0b0b(
SLinkOperations.getTarget(linkDeclaration, "target", false)),
_info_12389875345);
}
}
private static boolean renderingCondition_1clvom_a0a(SNode node, EditorContext editorContext) {
return (SLinkOperations.getTarget(node, "persistentConfiguration", false) == null)
|| (AttributeOperations.getAttribute(
SLinkOperations.getTarget(node, "persistentConfiguration", false),
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.execution.settings.structure.DeprecatedAnnotation"))
== null);
}
public void execute(final SNode node, final EditorContext editorContext) {
DocCommentHelper.addJavadocLangIfMissing(node);
if ((AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.baseLanguage.javadoc.structure.FieldDocComment")))
== null)) {
SNodeFactoryOperations.setNewAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.baseLanguage.javadoc.structure.FieldDocComment")),
"jetbrains.mps.baseLanguage.javadoc.structure.FieldDocComment");
SNode line =
SNodeFactoryOperations.addNewChild(
AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.baseLanguage.javadoc.structure.FieldDocComment"))),
"body",
"jetbrains.mps.baseLanguage.javadoc.structure.CommentLine");
SNodeFactoryOperations.addNewChild(
line, "part", "jetbrains.mps.baseLanguage.javadoc.structure.TextCommentLinePart");
} else {
AttributeOperations.setAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.baseLanguage.javadoc.structure.FieldDocComment")),
null);
}
editorContext.select(
ListSequence.fromList(
SLinkOperations.getTargets(
AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.baseLanguage.javadoc.structure.FieldDocComment"))),
"body",
true))
.first());
}
public void execute(final SNode node, final EditorContext editorContext) {
AttributeOperations.setAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"org.jetbrains.mps.samples.ParallelFor.structure.ThreadSafe")),
SNodeFactoryOperations.createNewNode(
"org.jetbrains.mps.samples.ParallelFor.structure.ThreadSafe", null));
}
public String getDescription(final SNode node, final EditorContext editorContext) {
return (AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.lang.editor.figures.structure.FigureParameterAttributeViewProperty"))
== null
? "Add figure parameter attribute"
: "Remove figure parameter attribute");
}
public String getDescription(final SNode node, final EditorContext editorContext) {
return ((AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.baseLanguage.javadoc.structure.FieldDocComment")))
== null)
? "Add Documentation Comment"
: "Remove Documentation Comment");
}
public boolean isApplicableToNode(final SNode node, final EditorContext editorContext) {
return SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(node, "operation", true),
"jetbrains.mps.baseLanguage.structure.InstanceMethodCallOperation")
&& AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"org.jetbrains.mps.samples.ParallelFor.structure.ThreadSafe")))
== null;
}
public void execute(final SNode node, final EditorContext editorContext) {
if (AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.lang.editor.figures.structure.FigureParameterAttributeViewProperty"))
!= null) {
AttributeOperations.setAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.lang.editor.figures.structure.FigureParameterAttributeViewProperty"),
null);
} else {
AttributeOperations.setAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.lang.editor.figures.structure.FigureParameterAttributeViewProperty"),
SConceptOperations.createNewNode(
"jetbrains.mps.lang.editor.figures.structure.FigureParameterAttributeViewProperty",
null));
}
}
private static boolean renderingCondition_rjgbfl_a2a(SNode node, EditorContext editorContext) {
return Sequence.fromIterable(
AttributeOperations.getChildNodesAndAttributes(
node,
MetaAdapterFactory.getContainmentLink(
0x698a8d22a10447a0L,
0xba8d10e3ec237f13L,
0x36fb0dc9fd32c1b8L,
0x36fb0dc9fd37a1c2L,
"additionalDependencies")))
.isNotEmpty();
}
private static boolean renderingCondition_gnweac_a1a(SNode node, EditorContext editorContext) {
return !((boolean)
BuildLayout_JarManifest__BehaviorDescriptor.isInJar_id5V$ev8kKReX.invoke(node))
|| Sequence.fromIterable(
AttributeOperations.getChildNodesAndAttributes(
node,
MetaAdapterFactory.getContainmentLink(
0x798100da4f0a421aL,
0xb99171f8c50ce5d2L,
0x115d3b22faf20f2eL,
0x67af4eb97391dfc1L,
"name")))
.isNotEmpty();
}
public void execute(final SNode node, final EditorContext editorContext) {
SNode newAnnotation =
SNodeFactoryOperations.createNewNode(
"jetbrains.mps.lang.test.structure.NodeOperationsContainer", null);
AttributeOperations.setAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.lang.test.structure.NodeOperationsContainer"),
newAnnotation);
SNode warningCheck =
SConceptOperations.createNewNode(
"jetbrains.mps.lang.test.structure.NodeWarningCheckOperation", null);
ListSequence.fromList(SLinkOperations.getTargets(newAnnotation, "nodeOperations", true))
.addElement(warningCheck);
SelectionUtil.selectCell(editorContext, warningCheck, SelectionManager.LAST_EDITABLE_CELL);
}
public static boolean filterIssue(SNode node) {
SNode container =
AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.lang.test.structure.NodeOperationsContainer"));
if (container == null) {
return true;
}
for (SNode property : SLinkOperations.getTargets(container, "nodeOperations", true)) {
if (jetbrains.mps.lang.smodel.generator.smodelAdapter.SNodeOperations.isInstanceOf(
property, "jetbrains.mps.lang.test.structure.NodeErrorCheckOperation")) {
return false;
}
}
return true;
}
public void execute(SNode node) {
SNodeOperations.deleteNode(
AttributeOperations.getAttribute(
SNodeOperations.cast(
node,
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x101d9d3ca30L,
"jetbrains.mps.baseLanguage.structure.Classifier")),
new IAttributeDescriptor.NodeAttribute(
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x53f7c33f069862f2L,
"jetbrains.mps.baseLanguage.structure.JavaImports"))));
}
public static SNode getApplicableConcept_fromEnvironment(SNode node) {
SNode ancestor =
SNodeOperations.getAncestorWhereConceptInList(
node,
new String[] {
"jetbrains.mps.lang.generator.structure.TemplateDeclaration",
"jetbrains.mps.lang.generator.structure.BaseMappingRule",
"jetbrains.mps.lang.generator.structure.PatternReduction_MappingRule"
},
false,
false);
if (SNodeOperations.isInstanceOf(
ancestor, "jetbrains.mps.lang.generator.structure.TemplateDeclaration")) {
return SLinkOperations.getTarget(
SNodeOperations.cast(
ancestor, "jetbrains.mps.lang.generator.structure.TemplateDeclaration"),
"applicableConcept",
false);
}
if (SNodeOperations.isInstanceOf(
ancestor, "jetbrains.mps.lang.generator.structure.PatternReduction_MappingRule")) {
return PatternReduction_MappingRule_Behavior.call_getConcept_1805153994417064763(
SNodeOperations.cast(
ancestor, "jetbrains.mps.lang.generator.structure.PatternReduction_MappingRule"));
}
if (SNodeOperations.isInstanceOf(
ancestor, "jetbrains.mps.lang.generator.structure.BaseMappingRule")) {
return SLinkOperations.getTarget(
SNodeOperations.cast(ancestor, "jetbrains.mps.lang.generator.structure.BaseMappingRule"),
"applicableConcept",
false);
}
// ============
SNode rootAnnotation =
AttributeOperations.getAttribute(
SNodeOperations.getContainingRoot(node),
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.generator.structure.RootTemplateAnnotation")));
return SLinkOperations.getTarget(
SNodeOperations.cast(
rootAnnotation, "jetbrains.mps.lang.generator.structure.RootTemplateAnnotation"),
"applicableConcept",
false);
}
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);
}
public static boolean call_isApplicable_5449224527592368025(
SAbstractConcept thisConcept, SNode node) {
return ListSequence.fromList(SNodeOperations.getReferences(node)).isNotEmpty()
&& (AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
MetaAdapterFactory.getConcept(
0x8585453e6bfb4d80L,
0x98deb16074f1d86cL,
0x7181d929c720809L,
"jetbrains.mps.lang.test.structure.ScopesTest")))
== null)
&& !(SNodeOperations.isInstanceOf(
node,
MetaAdapterFactory.getConcept(
0x8585453e6bfb4d80L,
0x98deb16074f1d86cL,
0x7181d929c720809L,
"jetbrains.mps.lang.test.structure.ScopesTest")));
}
private static Boolean isApplicable_id4IvydoGviup(
@NotNull SAbstractConcept __thisConcept__, SNode node) {
return Sequence.fromIterable(SNodeOperations.getReferences(node)).isNotEmpty()
&& (AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
MetaAdapterFactory.getConcept(
0x8585453e6bfb4d80L,
0x98deb16074f1d86cL,
0x7181d929c720809L,
"jetbrains.mps.lang.test.structure.ScopesTest")))
== null)
&& !(SNodeOperations.isInstanceOf(
node,
MetaAdapterFactory.getConcept(
0x8585453e6bfb4d80L,
0x98deb16074f1d86cL,
0x7181d929c720809L,
"jetbrains.mps.lang.test.structure.ScopesTest")));
}
public static SNode virtual_getExpectedReturnType_1213877374441(SNode thisNode) {
SNode referenceMacro =
SNodeOperations.getAncestor(
thisNode, "jetbrains.mps.lang.generator.structure.ReferenceMacro", false, false);
SNode attributedNode = SNodeOperations.getParent(referenceMacro);
String linkRole = AttributeOperations.getLinkRole(referenceMacro);
ConceptAndSuperConceptsScope linkSearchScope =
new ConceptAndSuperConceptsScope(SNodeOperations.getConceptDeclaration(attributedNode));
SNode link =
SNodeOperations.cast(
linkSearchScope.getMostSpecificLinkDeclarationByRole(linkRole),
"jetbrains.mps.lang.structure.structure.LinkDeclaration");
SNode targetConcept = SLinkOperations.getTarget(link, "target", false);
SNode expectedNodeType = _quotation_createNode_mxwyp3_a0g0a(targetConcept);
// reference may be resolved dynamically?
if (SConceptOperations.isSubConceptOf(
targetConcept, "jetbrains.mps.lang.core.structure.IResolveInfo")) {
return _quotation_createNode_mxwyp3_a0a8a0(targetConcept);
}
return expectedNodeType;
}
public void execute(final SNode node, final EditorContext editorContext) {
List<SNode> TFs =
SNodeOperations.getDescendants(
SLinkOperations.getTarget(
SLinkOperations.getTarget(node, "template", false), "contentNode", true),
"jetbrains.mps.lang.generator.structure.TemplateFragment",
true,
new String[] {});
if ((int) ListSequence.fromList(TFs).count() == 0) {
JOptionPane.showMessageDialog(null, "No fragments found");
return;
}
if (ListSequence.fromList(TFs).count() > 1) {
JOptionPane.showMessageDialog(null, "Too many fragments");
return;
}
// ------
SNode oldTemplate = SLinkOperations.getTarget(node, "template", false);
SNode fragmentToSet =
SNodeOperations.copyNode(SNodeOperations.getParent(ListSequence.fromList(TFs).first()));
SNode TFtoDelete =
AttributeOperations.getAttribute(
fragmentToSet,
new IAttributeDescriptor.NodeAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.generator.structure.TemplateFragment")));
SNodeOperations.deleteNode(TFtoDelete);
SNode inlineTemplate =
SNodeFactoryOperations.replaceWithNewChild(
node, "jetbrains.mps.lang.generator.structure.InlineTemplate_RuleConsequence");
SLinkOperations.setTarget(inlineTemplate, "templateNode", fragmentToSet, true);
// ------
int option =
JOptionPane.showConfirmDialog(
null, "Delete old template?", "", JOptionPane.YES_NO_OPTION);
if (option == JOptionPane.YES_OPTION) {
SNodeOperations.deleteNode(oldTemplate);
}
}
private boolean isApplicableToNode(final SNode node, final EditorContext editorContext) {
SNode annotation =
AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.lang.generator.structure.RootTemplateAnnotation"));
if (annotation == null) {
return false;
}
if (SLinkOperations.getTarget(annotation, "applicableConcept", false) == null) {
return false;
}
List<SNode> configs =
SModelOperations.getRoots(
SNodeOperations.getModel(node),
"jetbrains.mps.lang.generator.structure.MappingConfiguration");
if (ListSequence.fromList(configs).isEmpty()) {
return false;
}
SNode usage =
ListSequence.fromList(configs)
.findFirst(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return ListSequence.fromList(
SLinkOperations.getTargets(it, "rootMappingRule", true))
.findFirst(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return SLinkOperations.getTarget(it, "template", false) == node;
}
})
!= null;
}
});
// not used in rule yet?
return usage == null;
}
public void doGenerateText(SNode node) {
if (getBuffer().hasPositionsSupport()) {
TraceInfoGenerationUtil.createUnitInfo(this, node);
}
if ((AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.baseLanguage.javadoc.structure.ClassifierDocComment"))
!= null)) {
appendNode(
AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
"jetbrains.mps.baseLanguage.javadoc.structure.ClassifierDocComment")));
}
BaseLanguageTextGen.fileHeader(node, this);
BaseLanguageTextGen.annotations(node, this);
BaseLanguageTextGen.visibilityWithIndent(
SLinkOperations.getTarget(node, "visibility", true), this);
if (Classifier_Behavior.call_isInner_521412098689998677(node)
&& BehaviorReflection.invokeVirtual(
Boolean.TYPE, node, "virtual_isStatic_7405920559687241224", new Object[] {})) {
this.append("static ");
}
if (SPropertyOperations.getBoolean(node, "abstractClass")) {
this.append("abstract ");
}
if (SPropertyOperations.getBoolean(node, "isFinal")) {
this.append("final ");
}
this.append("class ");
this.append(SPropertyOperations.getString(node, "name"));
GenericDeclarationTextGen2.typeDeclarations(node, this);
if ((SLinkOperations.getTarget(node, "superclass", true) != null)) {
this.append(" extends ");
appendNode(SLinkOperations.getTarget(node, "superclass", true));
}
if (ListSequence.fromList(SLinkOperations.getTargets(node, "implementedInterface", true))
.isNotEmpty()) {
this.append(" implements ");
{
Iterable<SNode> collection = SLinkOperations.getTargets(node, "implementedInterface", true);
final SNode lastItem = Sequence.fromIterable(collection).last();
for (SNode item : collection) {
appendNode(item);
if (item != lastItem) {
append(", ");
}
}
}
}
this.append(" ");
BaseClassConceptTextGen.membersWithBrackets(node, true, this);
this.appendNewLine();
if (getBuffer().hasPositionsSupport()) {
{
String unitName = null;
try {
unitName =
BehaviorReflection.invokeVirtual(
String.class,
SNodeOperations.cast(node, "jetbrains.mps.lang.traceable.structure.UnitConcept"),
"virtual_getUnitName_5067982036267369911",
new Object[] {});
} catch (Throwable t) {
if (LOG.isEnabledFor(Level.ERROR)) {
LOG.error("Can't calculate unit name for a node " + node + ".", t);
}
}
TraceInfoGenerationUtil.fillUnitInfo(this, node, unitName);
}
}
}
public static SNode getEnclosing_SourceSubstituteMacro(SNode node, SNode currMacroNode) {
if (node == null) {
return null;
}
if (SNodeOperations.isInstanceOf(
node, "jetbrains.mps.lang.generator.structure.InlineTemplate_RuleConsequence")
|| SNodeOperations.isInstanceOf(
node,
"jetbrains.mps.lang.generator.structure.InlineTemplateWithContext_RuleConsequence")) {
SNode parent = SNodeOperations.getParent(node);
if ((parent == null)
|| !(SNodeOperations.isInstanceOf(
parent, "jetbrains.mps.lang.generator.structure.IfMacro"))
|| SLinkOperations.getTarget(
SNodeOperations.cast(parent, "jetbrains.mps.lang.generator.structure.IfMacro"),
"alternativeConsequence",
true)
!= node) {
return null;
}
}
List<SNode> attributes =
AttributeOperations.getAttributeList(node, new IAttributeDescriptor.AllAttributes());
SNode prevMacro = null;
for (SNode attribute : ListSequence.fromList(attributes)) {
if (attribute == currMacroNode) {
break;
}
if (SNodeOperations.isInstanceOf(
attribute, "jetbrains.mps.lang.generator.structure.SourceSubstituteMacro")) {
if (SNodeOperations.isInstanceOf(
attribute, "jetbrains.mps.lang.generator.structure.MapSrcNodeMacro")) {
if (SLinkOperations.getTarget(
SNodeOperations.cast(
attribute, "jetbrains.mps.lang.generator.structure.MapSrcNodeMacro"),
"sourceNodeQuery",
true)
== null) {
// the query is optional - continue 'enclosing macro' look-up
continue;
}
}
if (SNodeOperations.isInstanceOf(
attribute, "jetbrains.mps.lang.generator.structure.SwitchMacro")) {
if (SLinkOperations.getTarget(
SNodeOperations.cast(
attribute, "jetbrains.mps.lang.generator.structure.SwitchMacro"),
"sourceNodeQuery",
true)
== null) {
// the query is optional - continue 'enclosing macro' look-up
continue;
}
}
// ========
prevMacro =
SNodeOperations.cast(
attribute, "jetbrains.mps.lang.generator.structure.SourceSubstituteMacro");
}
}
// ========
if (prevMacro != null) {
return prevMacro;
}
return getEnclosing_SourceSubstituteMacro(SNodeOperations.getParent(node), null);
}
private boolean isApplicableToNode(final SNode node, final EditorContext editorContext) {
SNode annotation =
AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.NodeAttribute(
MetaAdapterFactory.getConcept(
0xb401a68083254110L,
0x8fd384331ff25befL,
0x11017244494L,
"jetbrains.mps.lang.generator.structure.RootTemplateAnnotation")));
if (annotation == null) {
return false;
}
if (SLinkOperations.getTarget(
annotation,
MetaAdapterFactory.getReferenceLink(
0xb401a68083254110L,
0x8fd384331ff25befL,
0x11017244494L,
0x11017255ccfL,
"applicableConcept"))
!= null) {
return false;
}
List<SNode> configs =
SModelOperations.roots(
SNodeOperations.getModel(node),
MetaAdapterFactory.getConcept(
0xb401a68083254110L,
0x8fd384331ff25befL,
0xff0bea0475L,
"jetbrains.mps.lang.generator.structure.MappingConfiguration"));
if (ListSequence.fromList(configs).isEmpty()) {
return false;
}
SNode usage =
ListSequence.fromList(configs)
.findFirst(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return ListSequence.fromList(
SLinkOperations.getChildren(
it,
MetaAdapterFactory.getContainmentLink(
0xb401a68083254110L,
0x8fd384331ff25befL,
0xff0bea0475L,
0x10fbbe00519L,
"createRootRule")))
.findFirst(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return SLinkOperations.getTarget(
it,
MetaAdapterFactory.getReferenceLink(
0xb401a68083254110L,
0x8fd384331ff25befL,
0x10fbbd5854aL,
0x10fbbd5854dL,
"templateNode"))
== node;
}
})
!= null;
}
});
// not used in rule yet?
return usage == null;
}
@Override
public List<SearchResult<ModelCheckerIssue>> checkModel(
SModel model, ProgressMonitor monitor, final IOperationContext operationContext) {
List<SearchResult<ModelCheckerIssue>> results =
ListSequence.fromList(new ArrayList<SearchResult<ModelCheckerIssue>>());
String title =
"Checking " + SModelOperations.getModelName(model) + " for wrong aspect dependencies...";
monitor.start(title, 1);
int modelKind = getModelKind(model, null);
if (modelKind == OTHER) {
monitor.done();
return results;
}
for (SNode node : ListSequence.fromList(SModelOperations.getNodes(model, null))) {
if (monitor.isCanceled()) {
break;
}
// Check for unresolved references
for (final SReference ref : Sequence.fromIterable(SNodeOperations.getReferences(node))) {
if ((AttributeOperations.getAttribute(
node,
new IAttributeDescriptor.LinkAttribute(
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.lang.generator.structure.ReferenceMacro"),
SLinkOperations.getRole(ref)))
!= null)) {
continue;
}
SNode targetNode = jetbrains.mps.util.SNodeOperations.getTargetNodeSilently(ref);
if (targetNode == null) {
addIssue(
results,
node,
"Unresolved reference: " + SLinkOperations.getResolveInfo(ref),
ModelChecker.SEVERITY_ERROR,
"unresolved reference",
new IModelCheckerFix() {
public boolean doFix() {
return ResolverComponent.getInstance().resolve(ref, operationContext);
}
});
continue;
}
SModel targetModel = SNodeOperations.getModel(targetNode);
int targetKind = getModelKind(targetModel, ref);
if (targetKind > modelKind) {
addIssue(
results,
node,
"Wrong reference: "
+ SLinkOperations.getResolveInfo(ref)
+ ", reference from "
+ kindToString(modelKind)
+ " to "
+ kindToString(targetKind),
ModelChecker.SEVERITY_ERROR,
"wrong aspect dependency (" + kindToString(modelKind) + ")",
null);
}
}
}
monitor.done();
return results;
}