public static SNode virtual_getAttachStatementChild_4797501453850305563(
SNode thisNode, SNode parentBuilder, SNode parentRef, SNode childRef) {
SNode result =
SNodeOperations.copyNode(
SLinkOperations.getTarget(
SLinkOperations.getTarget(thisNode, "declaration", false), "set", true));
for (SNode p :
SNodeOperations.getDescendants(
result,
"jetbrains.mps.baseLanguage.builders.structure.SimpleBuilderPropertyParent",
false,
new String[] {})) {
SNodeOperations.replaceWithAnother(p, SNodeOperations.copyNode(parentRef));
}
for (SNode v :
SNodeOperations.getDescendants(
result,
"jetbrains.mps.baseLanguage.builders.structure.SimpleBuilderPropertyValue",
false,
new String[] {})) {
SNodeOperations.replaceWithAnother(v, SNodeOperations.copyNode(childRef));
}
return result;
}
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 static boolean call_hasAnnotation_5499146221535822693(
SNode __thisNode__, SNode annotation) {
for (SNode annotationInstance :
SLinkOperations.getChildren(
__thisNode__,
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x114a6be947aL,
0x114a6beb0bdL,
"annotation"))) {
if (SLinkOperations.getTarget(
annotationInstance,
MetaAdapterFactory.getReferenceLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x114a6b4ccabL,
0x114a6b85d40L,
"annotation"))
== annotation) {
return true;
}
}
return false;
}
private String createMethodParameterTypesString(SNode method, Map<SNode, SNode> typeByTypeVar) {
StringBuilder result = new StringBuilder();
for (SNode parm :
SLinkOperations.getChildren(
method,
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf8cc56b1fcL,
0xf8cc56b1feL,
"parameter"))) {
SNode type =
SLinkOperations.getTarget(
parm,
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x450368d90ce15bc3L,
0x4ed4d318133c80ceL,
"type"));
type = GenericTypesUtil.getTypeWithResolvedTypeVars(type, typeByTypeVar);
if (result.length() > 0) {
result.append(',');
}
if (type != null) {
result.append(
((String)
BHReflection.invoke(
type, SMethodTrimmedId.create("getErasureSignature", null, "hEwIzNx"))));
} else {
result.append("");
}
}
return result.toString();
}
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 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 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 void applyRule(
final SNode op, final TypeCheckingContext typeCheckingContext, IsApplicableStatus status) {
{
SNode _nodeToCheck_1029348928467 = op;
EquationInfo _info_12389875345 =
new EquationInfo(
_nodeToCheck_1029348928467,
null,
"r:00000000-0000-4000-0000-011c895902f1(jetbrains.mps.lang.generator.generationContext.typesystem)",
"1216860931325",
0,
null);
typeCheckingContext.createEquation(
(SNode)
typeCheckingContext.typeOf(
_nodeToCheck_1029348928467,
"r:00000000-0000-4000-0000-011c895902f1(jetbrains.mps.lang.generator.generationContext.typesystem)",
"1216860931336",
true),
(SNode)
_quotation_createNode_tgcadk_a0a0b(
SLinkOperations.getTarget(
SLinkOperations.getTarget(op, "label", false), "targetConcept", false)),
_info_12389875345);
}
}
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 void applyRule(
final SNode efr, final TypeCheckingContext typeCheckingContext, IsApplicableStatus status) {
{
SNode _nodeToCheck_1029348928467 = efr;
EquationInfo _info_12389875345 =
new EquationInfo(
_nodeToCheck_1029348928467,
null,
"r:4b1ddbe6-5067-4a27-8697-eb786b50451b(jetbrains.mps.lang.extension.typesystem)",
"7036359038356115138",
0,
null);
typeCheckingContext.createEquation(
(SNode)
typeCheckingContext.typeOf(
_nodeToCheck_1029348928467,
"r:4b1ddbe6-5067-4a27-8697-eb786b50451b(jetbrains.mps.lang.extension.typesystem)",
"7036359038356115126",
true),
(SNode)
SLinkOperations.getTarget(
SLinkOperations.getTarget(efr, "declaration", false), "fieldType", true),
_info_12389875345);
}
}
private static SNode getDependencyTarget_id4RsV8qJH_ED(
@NotNull SNode __thisNode__, VisibleArtifacts artifacts) {
if (SNodeOperations.getContainingRoot(__thisNode__)
== SNodeOperations.getContainingRoot(
SLinkOperations.getTarget(
__thisNode__,
MetaAdapterFactory.getReferenceLink(
0x798100da4f0a421aL,
0xb99171f8c50ce5d2L,
0x4ddcec86afb65a3fL,
0x4ddcec86afb65a40L,
"folder")))) {
return null;
}
return JavaExportUtil.requireJarFolder(
artifacts,
SLinkOperations.getTarget(
__thisNode__,
MetaAdapterFactory.getReferenceLink(
0x798100da4f0a421aL,
0xb99171f8c50ce5d2L,
0x4ddcec86afb65a3fL,
0x4ddcec86afb65a40L,
"folder")),
__thisNode__);
}
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 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 static boolean baseMappingRule_Condition_1217891542034(
final BaseMappingRuleContext _context) {
return SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(
SNodeOperations.as(
SLinkOperations.getTarget(
_context.getNode(),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x11b0d00332cL,
0xf8c77f1e97L,
"lValue")),
MetaAdapterFactory.getConcept(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x116b46a08c4L,
"jetbrains.mps.baseLanguage.structure.DotExpression")),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x116b46a08c4L,
0x116b46b36c4L,
"operation")),
MetaAdapterFactory.getConcept(
0xd7706f639be2479cL,
0xa3daae92af1e64d5L,
0x11b8fe60348L,
"jetbrains.mps.lang.generator.generationContext.structure.GenerationContextOp_UserObjectAccessBase"));
}
public static boolean call_isVariableDefinedInThisMethod_1225456272518(SNode thisNode) {
// todo: method from LocalVariableReference. Remove
if (!(SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(thisNode, "variableDeclaration", false),
"jetbrains.mps.baseLanguage.structure.LocalVariableDeclaration"))) {
throw new IllegalArgumentException();
}
SNode anchor = thisNode;
if ((SNodeOperations.getAncestor(
thisNode, "jetbrains.mps.lang.quotation.structure.AbstractAntiquotation", false, false)
!= null)) {
anchor =
SNodeOperations.getAncestor(
thisNode, "jetbrains.mps.lang.quotation.structure.Quotation", false, false);
}
if (SNodeOperations.getAncestor(
anchor, "jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration", false, false)
== SNodeOperations.getAncestor(
SLinkOperations.getTarget(thisNode, "variableDeclaration", false),
"jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration",
false,
false)) {
if (SNodeOperations.getAncestor(
anchor, "jetbrains.mps.baseLanguage.structure.Closureoid", false, false)
== SNodeOperations.getAncestor(
SLinkOperations.getTarget(thisNode, "variableDeclaration", false),
"jetbrains.mps.baseLanguage.structure.Closureoid",
false,
false)) {
return true;
}
}
return false;
}
public static boolean baseMappingRule_Condition_1196428788645(
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"))
&& TypeChecker.getInstance()
.getSubtypingManager()
.isSubtype(
TypeChecker.getInstance()
.getTypeOf(
SLinkOperations.getTarget(
_context.getNode(),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfbdeb6fecfL,
0xfbdeb7a11bL,
"rightExpression"))),
_quotation_createNode_x583g4_b0a0a0c());
}
public void execute(SNode node) {
if ((boolean)
Expression__BehaviorDescriptor.singleValue_id1o8Ht9sES3u.invoke(
SNodeOperations.asSConcept(
SNodeOperations.getConceptDeclaration(
SLinkOperations.getTarget(
((SNode)
RemoveUnnecessaryParentheses_QuickFix.this
.getField("bottomLineParens")[0]),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfb4ed32b7fL,
0xfb4ed32b80L,
"expression")))))) {
SNodeOperations.replaceWithAnother(
node,
SLinkOperations.getTarget(
((SNode) RemoveUnnecessaryParentheses_QuickFix.this.getField("bottomLineParens")[0]),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xfb4ed32b7fL,
0xfb4ed32b80L,
"expression")));
}
SNodeOperations.replaceWithAnother(
node, ((SNode) RemoveUnnecessaryParentheses_QuickFix.this.getField("bottomLineParens")[0]));
}
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());
}
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 void build(
final IOperationContext operationContext, final DataFlowBuilderContext _context) {
_context
.getBuilder()
.build(
(SNode)
SLinkOperations.getTarget(
_context.getNode(),
MetaAdapterFactory.getContainmentLink(
0xf61473f9130f42f6L,
0xb98d6c438812c2f6L,
0x74f562a3a993fd3dL,
0x74f562a3a993fd44L,
"expected")));
_context
.getBuilder()
.build(
(SNode)
SLinkOperations.getTarget(
_context.getNode(),
MetaAdapterFactory.getContainmentLink(
0xf61473f9130f42f6L,
0xb98d6c438812c2f6L,
0x74f562a3a993fd3dL,
0x74f562a3a993fd45L,
"actual")));
}
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 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 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);
}
}
}
}
private boolean nodeCondition_d5p1uc_a2a() {
return (SLinkOperations.getTarget(
myNode,
MetaAdapterFactory.getReferenceLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x114a6b4ccabL,
0x114a6b85d40L,
"annotation"))
!= null)
&& ListSequence.fromList(
SLinkOperations.getChildren(
SLinkOperations.getTarget(
myNode,
MetaAdapterFactory.getReferenceLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x114a6b4ccabL,
0x114a6b85d40L,
"annotation")),
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x101d9d3ca30L,
0x101f2cc410bL,
"method")))
.isNotEmpty();
}
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);
}
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 String call_getErasureSignature_2830572026628006618(SNode __thisNode__) {
StringBuilder sb = new StringBuilder();
List<SNode> parameters =
SLinkOperations.getChildren(
__thisNode__,
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0xf8cc56b1fcL,
0xf8cc56b1feL,
"parameter"));
for (int i = 0; i < ListSequence.fromList(parameters).count(); i++) {
SNode param = ListSequence.fromList(parameters).getElement(i);
sb.append(
Type_BehaviorDescriptor.getErasureSignature_idhEwIzNx.invoke(
SLinkOperations.getTarget(
param,
MetaAdapterFactory.getContainmentLink(
0xf3061a5392264cc5L,
0xa443f952ceaf5816L,
0x450368d90ce15bc3L,
0x4ed4d318133c80ceL,
"type"))));
if (i < ListSequence.fromList(parameters).count() - 1) {
sb.append(",");
}
}
return sb.toString();
}
public static boolean call_isParameterOfThisMethod_1240394425603(SNode thisNode) {
// todo: method from ParameterReference. Remove.
if (!(SNodeOperations.isInstanceOf(
SLinkOperations.getTarget(thisNode, "variableDeclaration", false),
"jetbrains.mps.baseLanguage.structure.ParameterDeclaration"))) {
throw new IllegalArgumentException();
}
if (SNodeOperations.getAncestor(
thisNode, "jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration", false, false)
== SNodeOperations.getAncestor(
SLinkOperations.getTarget(thisNode, "variableDeclaration", false),
"jetbrains.mps.baseLanguage.structure.BaseMethodDeclaration",
false,
false)) {
if (SNodeOperations.getAncestor(
thisNode, "jetbrains.mps.baseLanguage.structure.Closureoid", false, false)
== SNodeOperations.getAncestor(
SLinkOperations.getTarget(thisNode, "variableDeclaration", false),
"jetbrains.mps.baseLanguage.structure.Closureoid",
false,
false)) {
return true;
}
}
return false;
}
/*package*/ static Money getCurrentPrice_id3u6SZi0yq4L(@NotNull SNode __thisNode__) {
if ((SLinkOperations.getTarget(
__thisNode__,
MetaAdapterFactory.getContainmentLink(
0x662a9f2b58024d16L,
0x955872c65c7a681eL,
0x3786e3f4808999c3L,
0x3786e3f480b0926aL,
"symbol"))
== null)) {
return new Money(BigDecimal.ZERO, "USD");
}
Money currentPrice =
StockPriceDownloader.getInstance()
.getCurrentPrice(
SPropertyOperations.getString(
SLinkOperations.getTarget(
__thisNode__,
MetaAdapterFactory.getContainmentLink(
0x662a9f2b58024d16L,
0x955872c65c7a681eL,
0x3786e3f4808999c3L,
0x3786e3f480b0926aL,
"symbol")),
MetaAdapterFactory.getProperty(
0x662a9f2b58024d16L,
0x955872c65c7a681eL,
0x3786e3f480a9b18aL,
0x3786e3f480afac5bL,
"symbol")));
if (currentPrice == null) {
return new Money(BigDecimal.ZERO, "USD");
}
return currentPrice;
}
public static List<SNode> call_getProperties_5389689214217081373(
SNode __thisNode__, SModel model) {
List<SNode> result = new ArrayList<SNode>();
for (SNode a :
SimpleBuilderDeclaration_BehaviorDescriptor.getAncestors_id6K2Bohp6U4S.invoke(
__thisNode__)) {
ListSequence.fromList(result)
.addSequence(
ListSequence.fromList(
SLinkOperations.getChildren(
a,
MetaAdapterFactory.getContainmentLink(
0x132aa4d8a3f7441cL,
0xa7eb3fce23492c6aL,
0x6524536b2e1a1e38L,
0x4acc05c8d729d207L,
"property"))));
}
for (SNode ext :
SimpleBuilderDeclaration_BehaviorDescriptor.getExtensions_id6K2Bohp73wF.invoke(
__thisNode__, model)) {
ListSequence.fromList(result)
.addSequence(
ListSequence.fromList(
SLinkOperations.getChildren(
ext,
MetaAdapterFactory.getContainmentLink(
0x132aa4d8a3f7441cL,
0xa7eb3fce23492c6aL,
0x56cd40dfa78dcaf3L,
0x56cd40dfa78dcaf5L,
"property"))));
}
return result;
}