private boolean isApplicableToNode(final SNode node, final EditorContext editorContext) {
return (SNodeOperations.getParent(node) != null)
&& SNodeOperations.isInstanceOf(
SNodeOperations.getParent(node),
MetaAdapterFactory.getConcept(
0x18bc659203a64e29L,
0xa83a7ff23bde13baL,
0xf9eaff2517L,
"jetbrains.mps.lang.editor.structure.CellModel_Collection"))
&& SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(
SNodeOperations.cast(
SNodeOperations.getParent(node),
MetaAdapterFactory.getConcept(
0x18bc659203a64e29L,
0xa83a7ff23bde13baL,
0xf9eaff2517L,
"jetbrains.mps.lang.editor.structure.CellModel_Collection")),
MetaAdapterFactory.getContainmentLink(
0x18bc659203a64e29L,
0xa83a7ff23bde13baL,
0xf9eaff2517L,
0x10192e0d3baL,
"cellLayout")),
MetaAdapterFactory.getConcept(
0x18bc659203a64e29L,
0xa83a7ff23bde13baL,
0x120150bb441L,
"jetbrains.mps.lang.editor.structure.CellLayout_Indent"))
&& !(EditorCellModel_BehaviorDescriptor.isNewLine_idi0pLPAc.invoke(node));
}
public static boolean baseMappingRule_Condition_1196429868936(
final BaseMappingRuleContext _context) {
return SNodeOperations.isInstanceOf(
TypeChecker.getInstance()
.getTypeOf(
SLinkOperations.getTarget(
_context.getNode(),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfbdeb6fecfL,
0xfbdeb7a11cL,
"leftExpression"))),
MetaAdapterFactory.getConcept(
0xff24ab03965e4d15L,
0x9aed52dc276658f4L,
0x11686a0422aL,
"jetbrains.mps.samples.complex.structure.ComplexType"))
&& SNodeOperations.isInstanceOf(
TypeChecker.getInstance()
.getTypeOf(
SLinkOperations.getTarget(
_context.getNode(),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfbdeb6fecfL,
0xfbdeb7a11bL,
"rightExpression"))),
MetaAdapterFactory.getConcept(
0xff24ab03965e4d15L,
0x9aed52dc276658f4L,
0x11686a0422aL,
"jetbrains.mps.samples.complex.structure.ComplexType"));
}
@Override
public void childRemoved(SModelChildEvent event) {
if (SNodeOperations.isInstanceOf(
((SNode) event.getParent()),
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x101d9d3ca30L,
"jetbrains.mps.baseLanguage.structure.Classifier"))) {
if (!(SNodeOperations.isInstanceOf(
((SNode) event.getChild()),
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf8cc56b1fcL,
"jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration")))) {
return;
}
}
if (SNodeOperations.isInstanceOf(
((SNode) event.getParent()),
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf8cc56b1fcL,
"jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration"))) {
String role = event.getChildRole();
if (!("parameter".equals(role))) {
return;
}
}
super.childRemoved(event);
}
private SNode getConceptDeclaration(SNode node, final Map<String, Object> _params) {
{
final SNode acd = node;
if (SNodeOperations.isInstanceOf(
acd,
MetaAdapterFactory.getConcept(
0xc72da2b97cce4447L,
0x8389f407dc1158b7L,
0x1103553c5ffL,
"jetbrains.mps.lang.structure.structure.AbstractConceptDeclaration"))) {
return acd;
}
}
{
final SNode conceptAspect = node;
if (SNodeOperations.isInstanceOf(
conceptAspect,
MetaAdapterFactory.getInterfaceConcept(
0xc72da2b97cce4447L,
0x8389f407dc1158b7L,
0x24614259e94f0c84L,
"jetbrains.mps.lang.structure.structure.IConceptAspect"))) {
return ((SNode)
BHReflection.invoke(
conceptAspect, SMethodTrimmedId.create("getBaseConcept", null, "2hxg_BDjKM8")));
}
}
return null;
}
private String getNodeName(SNode node, boolean isLast)
throws ArtifactsRelativePathHelper.RelativePathException {
if (SNodeOperations.isInstanceOf(node, "jetbrains.mps.build.structure.BuildLayout_Folder")) {
return getBSName(
SLinkOperations.getTarget(
SNodeOperations.cast(node, "jetbrains.mps.build.structure.BuildLayout_Folder"),
"containerName",
true));
} else if (SNodeOperations.isInstanceOf(node, "jetbrains.mps.build.structure.BuildLayout_Copy")
&& isLast) {
SNode fileset =
SLinkOperations.getTarget(
SNodeOperations.cast(node, "jetbrains.mps.build.structure.BuildLayout_Copy"),
"fileset",
true);
if (SNodeOperations.isInstanceOf(
fileset, "jetbrains.mps.build.structure.BuildInputSingleFile")) {
return BuildSourcePath_Behavior.call_getLastSegment_1368030936106771141(
SLinkOperations.getTarget(
SNodeOperations.cast(fileset, "jetbrains.mps.build.structure.BuildInputSingleFile"),
"path",
true),
null);
} else {
throw new ArtifactsRelativePathHelper.RelativePathException(
"cannot build relative path for copy, fileset is " + node.getConceptShortName());
}
}
throw new ArtifactsRelativePathHelper.RelativePathException(
"cannot build relative path for " + node.getConceptShortName());
}
@Override
public boolean isApplicable(SNode node) {
if (SNodeOperations.getParent(node) == null
|| !(SNodeOperations.isInstanceOf(
SNodeOperations.getParent(node),
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf8c108ca66L,
"jetbrains.mps.baseLanguage.structure.ClassConcept")))) {
return false;
}
if (!(SNodeOperations.isInstanceOf(
node,
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf8c108ca68L,
"jetbrains.mps.baseLanguage.structure.FieldDeclaration")))
&& !(SNodeOperations.isInstanceOf(
node,
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf93c84351fL,
"jetbrains.mps.baseLanguage.structure.StaticFieldDeclaration")))) {
return false;
}
return true;
}
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 SNode sourceNodeQuery_3624172675694702280(
final IOperationContext operationContext, final SourceSubstituteMacroNodeContext _context) {
// remove this method at all
SNode returnType = SLinkOperations.getTarget(_context.getNode(), "returnType", true);
if (SNodeOperations.isInstanceOf(
returnType, "jetbrains.mps.baseLanguage.structure.PrimitiveType")
|| (SNodeOperations.isInstanceOf(
returnType, "jetbrains.mps.baseLanguage.structure.ClassifierType")
&& ListSequence.fromList(
SLinkOperations.getTargets(
SNodeOperations.cast(
returnType, "jetbrains.mps.baseLanguage.structure.ClassifierType"),
"parameter",
true))
.isEmpty())
|| SNodeOperations.isInstanceOf(
returnType, "jetbrains.mps.baseLanguage.structure.StringType")) {
return BehaviorReflection.invokeVirtual(
(Class<SNode>) ((Class) Object.class),
returnType,
"virtual_getClassExpression_1213877337357",
new Object[] {});
} else {
return _quotation_createNode_x583g4_a0a0c0ac(returnType);
}
}
public Map<String, String> getContextClassifiers(SNode contextNode) {
// only AnonymousClass has Classifier as reference
// todo: make it clearer
if (SNodeOperations.isInstanceOf(
contextNode, "jetbrains.mps.baseLanguage.structure.IAnonymousClass")) {
contextNode = SNodeOperations.getParent(contextNode);
}
if (SNodeOperations.isInstanceOf(
contextNode, "jetbrains.mps.baseLanguage.structure.Classifier")) {
if (LOG.isEnabledFor(Level.WARN)) {
LOG.warn("contextNode is classifier in getContextClassifiers: " + contextNode);
}
return Collections.emptyMap();
}
// find first classifier in path
String sourceChildRole = null;
while ((contextNode != null)
&& !(SNodeOperations.isInstanceOf(
contextNode, "jetbrains.mps.baseLanguage.structure.Classifier"))) {
sourceChildRole = contextNode.getRoleInParent();
contextNode = SNodeOperations.getParent(contextNode);
}
if ((contextNode == null)) {
// todo: impossible?
return Collections.emptyMap();
}
return contextClassifiersCache.get(
MultiTuple.<SNode, String>from(
SNodeOperations.cast(contextNode, "jetbrains.mps.baseLanguage.structure.Classifier"),
sourceChildRole));
}
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;
}
}
}
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;
}
private static Boolean hasParameterRefs_id6qD99pUaonP(@NotNull SNode __thisNode__) {
SNode node = __thisNode__;
node = SNodeOperations.getParent(node);
while (node != null
&& !((SNodeOperations.isInstanceOf(
node,
MetaAdapterFactory.getInterfaceConcept(
0x7c9e280794ad4afcL,
0xadf0aaee45eb2895L,
0x48db75d5dc496a4fL,
"jetbrains.mps.samples.lambdaCalculus.structure.VariableOwner"))
&& !(ListSequence.fromList(
VariableOwner_BehaviorDescriptor.getVariables_id7M_MU5__$7C.invoke(
SNodeOperations.cast(
node,
MetaAdapterFactory.getInterfaceConcept(
0x7c9e280794ad4afcL,
0xadf0aaee45eb2895L,
0x48db75d5dc496a4fL,
"jetbrains.mps.samples.lambdaCalculus.structure.VariableOwner"))))
.contains(
SNodeOperations.as(
__thisNode__,
MetaAdapterFactory.getConcept(
0x7c9e280794ad4afcL,
0xadf0aaee45eb2895L,
0x48db75d5dc496b12L,
"jetbrains.mps.samples.lambdaCalculus.structure.Variable"))))))) {
node = SNodeOperations.getParent(node);
}
if (SNodeOperations.isInstanceOf(
node,
MetaAdapterFactory.getConcept(
0x7c9e280794ad4afcL,
0xadf0aaee45eb2895L,
0x448ba254edbfc79fL,
"jetbrains.mps.samples.lambdaCalculus.structure.LetExpression"))) {
return true;
}
if (!(SNodeOperations.isInstanceOf(
node,
MetaAdapterFactory.getConcept(
0x7c9e280794ad4afcL,
0xadf0aaee45eb2895L,
0x37d11ba7d7ec98e9L,
"jetbrains.mps.samples.lambdaCalculus.structure.LambdaExpression")))) {
return false;
}
return LambdaExpression_BehaviorDescriptor.isInFull_id6nQdzuslK0D.invoke(
SNodeOperations.cast(
node,
MetaAdapterFactory.getConcept(
0x7c9e280794ad4afcL,
0xadf0aaee45eb2895L,
0x37d11ba7d7ec98e9L,
"jetbrains.mps.samples.lambdaCalculus.structure.LambdaExpression")));
}
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 Map<String, String> getContextClassifiers(SNode contextNode, String sourceChildRole) {
Map<String, String> bindings = new HashMap<String, String>();
SNode current = contextNode;
while ((current != null)) {
if (SNodeOperations.isInstanceOf(
current, "jetbrains.mps.baseLanguage.structure.Classifier")) {
boolean processNestedClassifiers = false;
if (SNodeOperations.isInstanceOf(
current, "jetbrains.mps.baseLanguage.structure.AnonymousClass")
|| SNodeOperations.isInstanceOf(
current, "jetbrains.mps.baseLanguage.structure.EnumClass")) {
processNestedClassifiers = true;
} else if (SNodeOperations.isInstanceOf(
current, "jetbrains.mps.baseLanguage.structure.Interface")) {
processNestedClassifiers = !("extendedInterface".equals(sourceChildRole));
} else if (SNodeOperations.isInstanceOf(
current, "jetbrains.mps.baseLanguage.structure.ClassConcept")) {
processNestedClassifiers =
!("superclass".equals(sourceChildRole)
|| "implementedInterface".equals(sourceChildRole));
} else {
if (LOG.isEnabledFor(Level.WARN)) {
LOG.warn("Illegal classifier node in bl textgen: " + current);
}
}
// todo: is it true? had a bug with it. Look like nested classifier has more priority then
// class with same name
addClassifierToBindingMap(
bindings,
SNodeOperations.cast(current, "jetbrains.mps.baseLanguage.structure.Classifier"));
if (processNestedClassifiers) {
for (Map.Entry<String, String> simpleToFqName :
nestedClassifiersCache
.get(
SNodeOperations.cast(
current, "jetbrains.mps.baseLanguage.structure.Classifier"))
.entrySet()) {
if (!(bindings.containsKey(simpleToFqName.getKey()))) {
bindings.put(simpleToFqName.getKey(), simpleToFqName.getValue());
}
}
}
}
// todo: specialized links?
// should not be a problem: superclass/extendedInterface/implementedInterface not specialized
sourceChildRole = current.getRoleInParent();
current = SNodeOperations.getParent(current);
}
return bindings;
}
@Deprecated
private static boolean staticCanBeAChild_Old(
SNode node,
SNode parentNode,
SNode link,
SNode childConcept,
final IOperationContext operationContext) {
SNode pnode =
(SNodeOperations.isInstanceOf(
parentNode,
MetaAdapterFactory.getConcept(
0xcf935df46994e9cL,
0xa132fa109541cba3L,
0x14d3fb6fb843ebddL,
"jetbrains.mps.build.mps.structure.BuildMps_Group"))
? SNodeOperations.getParent(parentNode)
: parentNode);
return SNodeOperations.isInstanceOf(
pnode,
MetaAdapterFactory.getConcept(
0x798100da4f0a421aL,
0xb99171f8c50ce5d2L,
0x4df58c6f18f84a13L,
"jetbrains.mps.build.structure.BuildProject"))
&& ListSequence.fromList(
SLinkOperations.getChildren(
SNodeOperations.cast(
pnode,
MetaAdapterFactory.getConcept(
0x798100da4f0a421aL,
0xb99171f8c50ce5d2L,
0x4df58c6f18f84a13L,
"jetbrains.mps.build.structure.BuildProject")),
MetaAdapterFactory.getContainmentLink(
0x798100da4f0a421aL,
0xb99171f8c50ce5d2L,
0x4df58c6f18f84a13L,
0x5c3f3e2c1ce9ac70L,
"plugins")))
.any(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return SNodeOperations.isInstanceOf(
it,
MetaAdapterFactory.getConcept(
0xcf935df46994e9cL,
0xa132fa109541cba3L,
0xc0bde9fc71699d9L,
"jetbrains.mps.build.mps.structure.BuildMPSPlugin"));
}
})
|| pnode.getConcept().getQualifiedName().startsWith("jetbrains.mps.lang.generator");
}
private boolean isApplicableToNode(final SNode node, final EditorContext editorContext) {
return ListSequence.fromList(SLinkOperations.getTargets(node, "typeArgument", true)).isEmpty()
&& !((SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.LocalMethodCall")
&& (SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(
SNodeOperations.cast(
node, "jetbrains.mps.baseLanguage.structure.LocalMethodCall"),
"baseMethodDeclaration",
false),
"jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration"))));
}
public static ExtractMethodRefactoringParameters createParameters(List<SNode> nodes) {
SNode first = ListSequence.fromList(nodes).first();
if (SNodeOperations.isInstanceOf(first, "jetbrains.mps.baseLanguage.structure.Expression")
&& SNodeOperations.isInstanceOf(
SNodeOperations.getParent(first),
"jetbrains.mps.baseLanguage.structure.ExpressionStatement")) {
List<SNode> newNodes = new ArrayList<SNode>();
ListSequence.fromList(newNodes).addElement(SNodeOperations.getParent(first));
return new ExtractMethodRefactoringParameters(newNodes);
}
return new ExtractMethodRefactoringParameters(nodes);
}
public static boolean baseMappingRule_Condition_4540508509659909015(
final IOperationContext operationContext, final BaseMappingRuleContext _context) {
SNode lValue = SLinkOperations.getTarget(_context.getNode(), "lValue", true);
return SNodeOperations.isInstanceOf(
lValue, "jetbrains.mps.baseLanguage.structure.DotExpression")
&& SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(
SNodeOperations.cast(lValue, "jetbrains.mps.baseLanguage.structure.DotExpression"),
"operation",
true),
"jetbrains.mps.baseLanguage.structure.PropertyReference");
}
private void _populateLocalVariables(SNode loopStatement, List<SNode> result) {
for (SNode child : SNodeOperations.getChildren(loopStatement)) {
if (child.getRoleInParent().equals("body")) {
continue;
}
if (SNodeOperations.isInstanceOf(
child, "jetbrains.mps.baseLanguage.structure.LocalVariableDeclaration")) {
result.add(child);
}
// <node>
List<SNode> moreChildren = new ArrayList<SNode>();
if (SNodeOperations.isInstanceOf(
loopStatement, "jetbrains.mps.lang.typesystem.structure.MultipleForeachLoop")) {
ListSequence.fromList(moreChildren)
.addSequence(
ListSequence.fromList(
SLinkOperations.getTargets(
SNodeOperations.cast(
loopStatement,
"jetbrains.mps.lang.typesystem.structure.MultipleForeachLoop"),
"loopVariable",
true))
.where(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return (SLinkOperations.getTarget(it, "variable", true) != null);
}
})
.select(
new ISelector<SNode, SNode>() {
public SNode select(SNode it) {
return SLinkOperations.getTarget(it, "variable", true);
}
}));
}
for (SNode child_ : moreChildren) {
result.add(child_);
}
}
SNode containingLoop =
SNodeOperations.as(
LocalVariablesScope.findThisOrParent(
SNodeOperations.getParent(loopStatement),
SConceptOperations.findConceptDeclaration(
"jetbrains.mps.baseLanguage.structure.AbstractLoopStatement")),
"jetbrains.mps.baseLanguage.structure.AbstractLoopStatement");
if (containingLoop != null) {
this._populateLocalVariables(containingLoop, result);
}
}
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 static boolean virtual_onNewLine_3080189811177340422(SNode thisNode) {
SNode left = SNodeOperations.getPrevSibling(thisNode);
if (SNodeOperations.isInstanceOf(left, "jetbrains.mps.core.xml.structure.XmlValuePart")) {
SNode leftContent =
SNodeOperations.cast(left, "jetbrains.mps.core.xml.structure.XmlValuePart");
return SNodeOperations.isInstanceOf(
leftContent, "jetbrains.mps.core.xml.structure.XmlTextValue")
|| (SPropertyOperations.getString(thisNode, "text") == null
|| SPropertyOperations.getString(thisNode, "text").length() == 0)
&& (SNodeOperations.getNextSibling(thisNode) == null);
}
return false;
}
private boolean isApplicableToNode(final SNode node, final EditorContext editorContext) {
SNode ruleNode =
SNodeOperations.getAncestor(
node, "jetbrains.mps.lang.generator.structure.BaseMappingRule", false, false);
if (!(SNodeOperations.isInstanceOf(
ruleNode, "jetbrains.mps.lang.generator.structure.Root_MappingRule")
|| SNodeOperations.isInstanceOf(
ruleNode, "jetbrains.mps.lang.generator.structure.Weaving_MappingRule")
|| SNodeOperations.isInstanceOf(
ruleNode, "jetbrains.mps.lang.generator.structure.Reduction_MappingRule"))) {
return false;
}
return true;
}
public static List<SNode> virtual_getMethodsToOverride_5418393554803767537(SNode thisNode) {
List<SNode> methods = new ArrayList<SNode>();
for (SNode method :
Sequence.fromIterable(
IClassifierType_Behavior.call_getMembers_7405920559687277275(
BehaviorReflection.invokeVirtual(
(Class<SNode>) ((Class) Object.class),
thisNode,
"virtual_getThisType_7405920559687254782",
new Object[] {})))
.where(
new IWhereFilter<SNode>() {
public boolean accept(SNode it) {
return SNodeOperations.isInstanceOf(
it, "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration");
}
})
.select(
new ISelector<SNode, SNode>() {
public SNode select(SNode it) {
return SNodeOperations.cast(
it, "jetbrains.mps.baseLanguage.structure.InstanceMethodDeclaration");
}
})) {
SNode cls =
SNodeOperations.getAncestor(
method, "jetbrains.mps.baseLanguage.structure.Classifier", false, false);
if (cls == thisNode) {
continue;
}
if (!(SNodeOperations.isInstanceOf(
cls, "jetbrains.mps.baseLanguage.structure.ClassConcept"))) {
continue;
}
if (SPropertyOperations.getBoolean(method, "isFinal")) {
continue;
}
if (SPropertyOperations.getBoolean(method, "isAbstract")) {
continue;
}
if (SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(method, "visibility", true),
"jetbrains.mps.baseLanguage.structure.PrivateVisibility")) {
continue;
}
ListSequence.fromList(methods).addElement(method);
}
return methods;
}
public boolean isApplicableToNode(final SNode node, final EditorContext editorContext) {
return (SNodeOperations.getParent(node) != null)
&& SNodeOperations.isInstanceOf(
SNodeOperations.getParent(node),
"jetbrains.mps.lang.editor.structure.CellModel_Collection")
&& SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(
SNodeOperations.cast(
SNodeOperations.getParent(node),
"jetbrains.mps.lang.editor.structure.CellModel_Collection"),
"cellLayout",
true),
"jetbrains.mps.lang.editor.structure.CellLayout_Indent")
&& !(EditorCellModel_Behavior.call_isNewLine_1237383076236(node));
}
private Map<SNode, Boolean> getOverloadedOperators(SNode node, SNode leftType, SNode rightType) {
Map<SNode, Boolean> result = MapSequence.fromMap(new HashMap<SNode, Boolean>());
if (!(SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.BinaryOperation"))) {
return result;
}
for (SNode operator : getOperatorContainers()) {
if (isOverloading(
SNodeOperations.cast(node, "jetbrains.mps.baseLanguage.structure.BinaryOperation"),
leftType,
rightType,
operator)) {
MapSequence.fromMap(result).put(operator, false);
}
if (SPropertyOperations.getBoolean(operator, "commutative")
&& isOverloading(
SNodeOperations.cast(node, "jetbrains.mps.baseLanguage.structure.BinaryOperation"),
rightType,
leftType,
operator)) {
MapSequence.fromMap(result).put(operator, true);
}
}
return result;
}
public SNode getNearestOverloaded(SNode node, SNode leftType, SNode rightType) {
if (!(SNodeOperations.isInstanceOf(
node, "jetbrains.mps.baseLanguage.structure.BinaryOperation"))) {
return null;
}
SNode result = (SNode) (node.getUserObject("operator"));
if (result != null) {
return result;
}
Map<SNode, Boolean> operatorMap =
getOverloadedOperators(
SNodeOperations.cast(node, "jetbrains.mps.baseLanguage.structure.BinaryOperation"),
leftType,
rightType);
if (MapSequence.fromMap(operatorMap).isEmpty()) {
return null;
}
result = MapSequence.fromMap(operatorMap).first().key();
boolean resultReversed = MapSequence.fromMap(operatorMap).first().value();
for (IMapping<SNode, Boolean> operatorEntry : MapSequence.fromMap(operatorMap)) {
SNode operator = operatorEntry.key();
boolean reversed = operatorEntry.value() != resultReversed;
if (isSubTypeOperator(operator, result, reversed)) {
result = operator;
resultReversed = operatorEntry.value();
}
}
node.putUserObject("operator", result);
node.putUserObject("reversed", resultReversed);
return result;
}
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_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);
}
}
@Override
protected void doFind(
SNode node, SearchScope scope, List<SNode> _results, ProgressMonitor monitor) {
monitor.start(getDescription(), 1);
try {
for (SNode nodeUsage :
FindUtils.executeFinder(
"jetbrains.mps.lang.structure.findUsages.NodeUsages_Finder",
node,
scope,
monitor.subTask(1))) {
if (SNodeOperations.hasRole(
nodeUsage,
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf8c108ca66L,
0x10f6353296dL,
"superclass"))) {
ListSequence.fromList(_results).addElement(SNodeOperations.getParent(nodeUsage));
} else if (SNodeOperations.isInstanceOf(
nodeUsage,
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x1107e0cb103L,
"jetbrains.mps.baseLanguage.structure.AnonymousClass"))) {
ListSequence.fromList(_results).addElement(nodeUsage);
}
}
} finally {
monitor.done();
}
}
private static List<SNode> getImplementedAndExtended(
SNode classifier, Map<SNode, SNode> typeByTypeVar) {
Set<SNode> set = SetSequence.fromSet(new LinkedHashSet<SNode>());
ClassifierAndSuperClassifiersCache.ClassifiersDataSet.collectImplementedAndExtended(
classifier, set, null, typeByTypeVar);
List<SNode> result = new ArrayList<SNode>();
ListSequence.fromList(result).addSequence(SetSequence.fromSet(set));
SNode objectClass =
SNodeOperations.getNode(
"6354ebe7-c22a-4a0f-ac54-50b52ab9b065/java:java.lang(JDK/)", "~Object");
if (objectClass != null && !(SetSequence.fromSet(set).contains(objectClass))) {
int indexOfFirstInterface = 0;
for (SNode classifierInResult : set) {
if (SNodeOperations.isInstanceOf(
classifierInResult,
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x101edd46144L,
"jetbrains.mps.baseLanguage.structure.Interface"))) {
break;
}
indexOfFirstInterface++;
}
if (indexOfFirstInterface == 0) {
result.add(objectClass);
} else {
result.add(indexOfFirstInterface, objectClass);
}
}
return result;
}
