public IfStatement(LexicalInfo token, Expression condition, Block trueBlock, Block falseBlock) : base(token) { this.Condition = condition; this.TrueBlock = trueBlock; this.FalseBlock = falseBlock; }
public Slice(LexicalInfo lexicalInfo, Expression begin, Expression end, Expression step) : base(lexicalInfo) { this.Begin = begin; this.End = end; this.Step = step; }
public static bool IsLogicalCondition(Expression node) { Node condition = node; while (IsLogicalExpression(condition.ParentNode)) condition = condition.ParentNode; return IsConditionOfConditionalStatement(condition); }
public object VisitGotoCaseStatement(GotoCaseStatement gotoCaseStatement, object data) { if (currentSwitchTempName == null) { AddError(gotoCaseStatement, "goto case cannot be used outside switch"); return(null); } string labelName; if (gotoCaseStatement.IsDefaultCase) { labelName = "default"; } else { B.Expression expr = ConvertExpression(gotoCaseStatement.Expression); if (expr == null) { return(null); } labelName = expr.ToCodeString().GetHashCode().ToString(System.Globalization.NumberFormatInfo.InvariantInfo); } return(new B.GotoStatement(GetLexicalInfo(gotoCaseStatement), new B.ReferenceExpression(currentSwitchTempName + "_" + labelName))); }
public IReturnType GetTypeOfExpression(AST.Expression expr, IClass callingClass) { AST.Node node = expr; AST.LexicalInfo lexInfo; do { if (node == null) { return(null); } lexInfo = node.LexicalInfo; node = node.ParentNode; } while (lexInfo == null || lexInfo.FileName == null); if (!Initialize(ParserService.GetParseInformation(lexInfo.FileName), lexInfo.Line, lexInfo.Column)) { return(null); } if (callingClass != null) { this.callingClass = callingClass; } ResolveVisitor visitor = new ResolveVisitor(this); visitor.Visit(expr); if (visitor.ResolveResult == null) { return(null); } else { return(visitor.ResolveResult.ResolvedType); } }
private Expression ExplicitBooleanContext(Expression expression) { var type = GetExpressionType(expression); if (type == TypeSystemServices.BoolType) { return expression; } // happening //Trace.Assert(!TypeSystemServices.IsError(expression), "shouldn't have error boolean expression."); if (TypeSystemServices.IsNumber(type) || type.IsEnum) { return CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.Equality, expression, CodeBuilder.CreateIntegerLiteral(0)); } else if (TypeSystemServices.IsReferenceType(type)) { return CodeBuilder.CreateBoundBinaryExpression( TypeSystemServices.BoolType, BinaryOperatorType.Equality, expression, CodeBuilder.CreateNullLiteral()); } return expression; }
public BinaryExpression(LexicalInfo lexicalInfoProvider, BinaryOperatorType operator_, Expression left, Expression right) : base(lexicalInfoProvider) { this.Operator = operator_; this.Left = left; this.Right = right; }
public override void PropagateChanges(MethodInvocationExpression eval, List chain) { ExpressionCollection expressions = new ExpressionCollection(); foreach (object local1 in chain.Reversed) { if (!(local1 is ProcessAssignmentsToSpecialMembers.ChainItem)) { } ProcessAssignmentsToSpecialMembers.ChainItem item = (ProcessAssignmentsToSpecialMembers.ChainItem) RuntimeServices.Coerce(local1, typeof(ProcessAssignmentsToSpecialMembers.ChainItem)); if (item.Container is MethodInvocationExpression) { break; } if (item.Container is SlicingExpression) { SlicingExpression expression = item.Container; Expression[] expressionArray1 = new Expression[] { expression.get_Target().CloneNode(), expression.get_Indices().get_Item(0).get_Begin().CloneNode(), this.get_CodeBuilder().CreateReference(item.Local) }; expressions.Add(this.CreateConstructorInvocation(this._sliceValueTypeChangeConstructor, expressionArray1)); break; } MemberReferenceExpression container = item.Container; Expression[] args = new Expression[] { container.get_Target().CloneNode(), this.get_CodeBuilder().CreateStringLiteral(container.get_Name()), this.get_CodeBuilder().CreateReference(item.Local) }; expressions.Add(this.CreateConstructorInvocation(this._valueTypeChangeConstructor, args)); } MethodInvocationExpression expression3 = this.get_CodeBuilder().CreateMethodInvocation(this._propagateChanges); IArrayType type = this._valueTypeChangeType.MakeArrayType(1); expression3.get_Arguments().Add(this.get_CodeBuilder().CreateArray(type, expressions)); eval.get_Arguments().Add(expression3); }
public static Expression ComparisonFor(Expression local, IEnumerable<Expression> expressions) { BinaryExpression expression; IEnumerator<Expression> enumerator = expressions.GetEnumerator(); if (!enumerator.MoveNext()) { throw new AssertionFailedException("e.MoveNext()"); } BinaryExpression expression1 = expression = new BinaryExpression(LexicalInfo.Empty); expression.set_Operator(11); expression.set_Left(Expression.Lift(local)); expression.set_Right(Expression.Lift(enumerator.Current)); Expression expression2 = expression; while (enumerator.MoveNext()) { BinaryExpression expression3; BinaryExpression expression4; BinaryExpression expression11 = expression4 = new BinaryExpression(LexicalInfo.Empty); expression4.set_Operator(0x1c); expression4.set_Left(Expression.Lift(expression2)); BinaryExpression expression12 = expression3 = new BinaryExpression(LexicalInfo.Empty); expression3.set_Operator(11); expression3.set_Left(Expression.Lift(local)); expression3.set_Right(Expression.Lift(enumerator.Current)); expression4.set_Right(expression3); expression2 = expression4; } return expression2; }
public object VisitInvocationExpression(InvocationExpression ie, object data) { B.Expression e = ConvertExpression(ie.TargetObject); if (e == null) { return(null); } if (settings.IsVisualBasic && ie.TargetObject is IdentifierExpression && currentStatement != null) { VariableResolver resolver = new VariableResolver(nameComparer); TypeReference typeRef = resolver.FindType((ie.TargetObject as IdentifierExpression).Identifier, currentStatement); if (typeRef != null && typeRef.IsArrayType) { // Visual Basic: indexer expression B.SlicingExpression s = new B.SlicingExpression(GetLexicalInfo(ie)); s.Target = e; foreach (Expression expr in ie.Arguments) { s.Indices.Add(new B.Slice(ConvertExpression(expr))); } return(s); } } B.MethodInvocationExpression r = new B.MethodInvocationExpression(GetLexicalInfo(ie), e); foreach (Expression expr in ie.Arguments) { e = ConvertExpression(expr); if (e != null) { r.Arguments.Add(e); } } return(r); }
private static bool IsTryGetParameterInvocation(Expression condition) { var expression = condition as ReferenceExpression; if (expression == null) return false; return expression.Name.StartsWith("?"); }
public static MethodInvocationExpression CreateMethodInvocationExpression(LexicalInfo li, Expression target, Expression arg) { MethodInvocationExpression mie = new MethodInvocationExpression(li); mie.Target = (Expression)target.Clone(); mie.Arguments.Add((Expression)arg.Clone()); mie.IsSynthetic = true; return mie; }
public Expression Reify(Expression node) { if (ShouldReify()) { RunExpansionIterations(); } return node; }
private Expression FixCondition(Expression condition) { if (IsTryGetParameterInvocation(condition) == false) return condition; var isNull = new MemberReferenceExpression(condition, "_IsIgnoreNullReferencingNotNullObject_"); return isNull; }
private static bool IsTryGetParameterInvocation(Expression condition) { var mie = condition as MethodInvocationExpression; if (mie == null) return false; var expression = mie.Target as ReferenceExpression; if (expression == null) return false; return expression.Name == "TryGetParameter"; }
public static Expression when(Expression expression) { BlockExpression right = new BlockExpression(); right.Body.Add(new ReturnStatement(expression)); return new BinaryExpression( BinaryOperatorType.Assign, new ReferenceExpression("condition"), right ); }
protected override bool IsSpecialMemberTarget(Expression container) { if (container.NodeType == NodeType.UnaryExpression) { UnaryExpression ue = container as UnaryExpression; if (ue.Operator == UnaryOperatorType.Indirection) return false; //indirected value type, no need to process it specially } return null != container.ExpressionType && container.ExpressionType.IsValueType; }
public static Expression when(Expression expression, Expression action) { BlockExpression condition = new BlockExpression(); condition.Body.Add(new ReturnStatement(expression)); return new MethodInvocationExpression( new ReferenceExpression("When"), condition, action ); }
private static string ParameterNameFrom(Expression target) { switch (target.NodeType) { case NodeType.ReferenceExpression: return ((ReferenceExpression) target).Name; case NodeType.SelfLiteralExpression: return "self"; } throw new ArgumentException(target.ToCodeString()); }
protected static void RegisterExtension(MacroStatement macro, Expression extension) { var extenstions = macro[ExtensionsKey] as List<Expression>; if (extenstions == null) { extenstions = new List<Expression>(); macro[ExtensionsKey] = extenstions; } extenstions.Add(extension); }
void ConvertExpressions(IEnumerable input, B.ExpressionCollection output) { foreach (Expression e in input) { B.Expression expr = ConvertExpression(e); if (expr != null) { output.Add(expr); } } }
public static ParameterDeclaration Lift(Expression e) { if (e == null) return null; switch (e.NodeType) { case NodeType.TryCastExpression: return Lift((TryCastExpression)e); case NodeType.ReferenceExpression: return Lift((ReferenceExpression)e); } throw new NotImplementedException(e.ToCodeString()); }
public object VisitEraseStatement(EraseStatement eraseStatement, object data) { ArrayList statements = new ArrayList(); foreach (Expression expr in eraseStatement.Expressions) { B.Expression e = ConvertExpression(expr); e = new B.BinaryExpression(B.BinaryOperatorType.Assign, e, new B.NullLiteralExpression()); statements.Add(new B.ExpressionStatement(e)); } return(statements); }
public static Statement when(Expression expression) { var body = new Block(expression.LexicalInfo); body.Add(new ReturnStatement(expression)); var result = new BlockExpression(body); result.Parameters.Add( new ParameterDeclaration("order", CurrentContext.CodeBuilder.CreateTypeReference(typeof(Order)))); result.Parameters.Add( new ParameterDeclaration("customer", CurrentContext.CodeBuilder.CreateTypeReference(typeof(Customer)))); return new ReturnStatement(result); }
private Expression ReplaceExpression(Expression expression) { if ((expression is MethodInvocationExpression) == false) return expression; var mie = (MethodInvocationExpression)expression; var expressionType = mie.ExpressionType as ExternalType; if (expressionType != null && typeof(IRegisterable).IsAssignableFrom(expressionType.ActualType)) { return CodeBuilder.CreateMethodInvocation(mie, RegisterMethod); } return expression; }
B.TypeReference ConvertTypeReference(B.Expression expr) { B.TypeofExpression te = expr as B.TypeofExpression; if (te != null) { return(te.Type); } if (expr is B.ReferenceExpression) { return(new B.SimpleTypeReference(expr.ToCodeString())); } AddError(expr.LexicalInfo, "Expected type, but found expression."); return(null); }
public static bool IsCompoundAssignment(Expression expression, out ArrayLiteralExpression assignments) { assignments = expression as ArrayLiteralExpression; if (assignments != null) { BinaryExpression assignment; return (assignments.Items.Count > 1 && IsAssignment(assignments.Items[1], out assignment)); } return false; }
public object VisitAttribute(ICSharpCode.NRefactory.Ast.Attribute a, object data) { B.Attribute att = new B.Attribute(GetLexicalInfo(a), a.Name); att.EndSourceLocation = GetLocation(a.EndLocation); ConvertExpressions(a.PositionalArguments, att.Arguments); foreach (NamedArgumentExpression nae in a.NamedArguments) { B.Expression expr = ConvertExpression(nae.Expression); if (expr != null) { att.NamedArguments.Add(new B.ExpressionPair(new B.ReferenceExpression(nae.Name), expr)); } } return(att); }
public object VisitBinaryOperatorExpression(BinaryOperatorExpression binaryOperatorExpression, object data) { B.Expression left = ConvertExpression(binaryOperatorExpression.Left); B.Expression right = ConvertExpression(binaryOperatorExpression.Right); B.BinaryOperatorType op = ConvertOperator(binaryOperatorExpression.Op); if (op == B.BinaryOperatorType.None) { AddError(binaryOperatorExpression, "Unknown operator."); return(null); } // if (binaryOperatorExpression.Op == BinaryOperatorType.DivideInteger) { // AddWarning(binaryOperatorExpression, "Integer division converted to normal division."); // } return(new B.BinaryExpression(GetLexicalInfo(binaryOperatorExpression), op, left, right)); }
public object VisitUnaryOperatorExpression(UnaryOperatorExpression unaryOperatorExpression, object data) { B.Expression expr = ConvertExpression(unaryOperatorExpression.Expression); if (unaryOperatorExpression.Op == UnaryOperatorType.Plus) { return(expr); } B.UnaryOperatorType op = ConvertOperator(unaryOperatorExpression.Op); if (op == B.UnaryOperatorType.None) { AddError(unaryOperatorExpression, "Unknown operator."); return(null); } return(new B.UnaryExpression(GetLexicalInfo(unaryOperatorExpression), op, expr)); }
public static TypeReference Lift(Expression e) { switch (e.NodeType) { case NodeType.TypeofExpression: return Lift((TypeofExpression) e); case NodeType.GenericReferenceExpression: return Lift((GenericReferenceExpression) e); case Ast.NodeType.ReferenceExpression: return Lift((ReferenceExpression) e); case Ast.NodeType.MemberReferenceExpression: return Lift((MemberReferenceExpression) e); } throw new NotImplementedException(e.ToCodeString()); }
private string NamespaceFrom(Expression e) { if (e == null) return null; var reference = e as ReferenceExpression; if (reference != null) return reference.ToString(); var s = e as StringLiteralExpression; if (s != null) return s.Value; return NamespaceFrom(((MethodInvocationExpression) e).Target); }
public static bool IsRhsOfAssignment(Expression node) { Expression expression2; Node node2 = node.get_ParentNode(); if (node2 is BinaryExpression) { BinaryExpression expression; BinaryExpression expression1 = expression = node2; if ((1 != 0) && (expression.get_Operator() == 15)) { Expression expression3 = expression2 = expression.get_Right(); } } return ((1 != 0) && (expression2 == node)); }
private Expression FixCondition(Expression condition) { if (IsTryGetParameterInvocation(condition) == false) return condition; string name = ((ReferenceExpression) condition).Name.Substring(1); condition = new MethodInvocationExpression( new MemberReferenceExpression(new SuperLiteralExpression(), "TryGetParameter"), new StringLiteralExpression(name) ); var isNull = new MemberReferenceExpression(condition, "_IsIgnoreNullReferencingNotNullObject_"); return isNull; }
public bool IsRunnable(Expression expression) { var method = expression as MethodInvocationExpression; if (method == null) return false; var reference = method.Target as ReferenceExpression; if (reference == null) return false; var targetType = nameResolutionService.Resolve(reference.Name, EntityType.Type) as IType; if (targetType == null) return false; var interfaces = targetType.GetInterfaces(); if (!interfaces.Any(IsRunnable)) return false; return true; }
public static Statement read (Expression expression){ Declaration declaraion = new Declaration(); declaraion.Name = "readedContent"; Expression arg = null; if (expression is BinaryExpression){ var ass = expression as BinaryExpression; declaraion.Name=ass.Left.LiftToString(); arg = ass.Right; }else{ arg = expression; } MethodInvocationExpression assign = AstUtil.CreateMethodInvocationExpression(AstUtil.CreateReferenceExpression("System.IO.File.ReadAllText"), arg); var result = new DeclarationStatement(declaraion, assign); return result; }
public bool GetNode(Expression expression, bool asAttribute, CompilerErrorCollection compileErrors) { _isAttribute = asAttribute; _compileErrors = compileErrors; Visit(expression); if (_node == null) { _compileErrors.Add(CompilerErrorFactory.CustomError(expression.LexicalInfo, "Unrecgonized configuration node syntax")); return false; } return true; }
public override void OnMemberReferenceExpression(MemberReferenceExpression node) { ReferenceExpression reference = node.Target as ReferenceExpression; if (reference != null && reference.Name.StartsWith("@")) { _component = reference; } else { _component = AstUtil.CreateMethodInvocationExpression( AstUtil.CreateReferenceExpression(typeof(ComponentReference).FullName), node.Target ); } _method = new StringLiteralExpression(node.Name); _found = true; }
private Block extractMainItemBlock(MacroStatement macro, Func<MacroStatement, Block> extract, MacroStatement onitem_macro, Expression item, string prefix, string suffix){ Block onitem = null; if (onitem_macro == macro && (macro.Body == null || macro.Body.IsEmpty)){ Expression outer = item; if (prefix != "" || suffix != ""){ outer = new ExpressionInterpolationExpression() .append(prefix) .append(item) .append(suffix); } onitem = new Block().add(BrailBuildingHelper.WriteOut(outer)); } else{ onitem = extract(onitem_macro); } return onitem; }
public object VisitAssignmentExpression(AssignmentExpression assignmentExpression, object data) { B.Expression left = ConvertExpression(assignmentExpression.Left); B.Expression right = ConvertExpression(assignmentExpression.Right); bool isInPlace; B.BinaryOperatorType op = ConvertOperator(assignmentExpression.Op, out isInPlace); if (op == B.BinaryOperatorType.None) { AddError(assignmentExpression, "Unknown operator."); return(null); } if (!isInPlace) { // convert L <OP>= R to L = L OP R right = new B.BinaryExpression(GetLexicalInfo(assignmentExpression), op, left, right); op = B.BinaryOperatorType.Assign; } return(new B.BinaryExpression(GetLexicalInfo(assignmentExpression), op, left, right)); }
public object VisitCompilationUnit(CompilationUnit compilationUnit, object data) { module = new B.Module(); module.LexicalInfo = new B.LexicalInfo(fileName, 1, 1); compilationUnit.AcceptChildren(this, data); if (entryPointMethod != null) { bool allMembersAreStatic = true; foreach (B.TypeMember member in entryPointMethod.DeclaringType.Members) { allMembersAreStatic &= member.IsStatic; } if (allMembersAreStatic) { entryPointMethod.DeclaringType.Attributes.Add(MakeAttribute(("module"))); } else { lastLexicalInfo = entryPointMethod.LexicalInfo; B.Expression expr = MakeReferenceExpression(entryPointMethod.DeclaringType.Name + ".Main"); B.MethodInvocationExpression mie = new B.MethodInvocationExpression(lastLexicalInfo, expr); if (entryPointMethod.Parameters.Count > 0) { mie.Arguments.Add(MakeReferenceExpression("argv")); } B.SimpleTypeReference ret = entryPointMethod.ReturnType as B.SimpleTypeReference; if (ret.Name == "void" || ret.Name == "System.Void") { module.Globals.Add(new B.ExpressionStatement(mie)); } else { module.Globals.Add(new B.ReturnStatement(lastLexicalInfo, mie, null)); } } } B.Module tmp = module; module = null; return(tmp); }
public object VisitForNextStatement(ForNextStatement forNextStatement, object data) { if (forNextStatement.TypeReference.IsNull) { return(MakeManualLoop(forNextStatement)); } B.ForStatement fs = new B.ForStatement(GetLexicalInfo(forNextStatement)); fs.Block = ConvertBlock(forNextStatement.EmbeddedStatement); fs.Declarations.Add(new B.Declaration(forNextStatement.VariableName, null)); B.Expression start = ConvertExpression(forNextStatement.Start); Expression end = forNextStatement.End; if (forNextStatement.Step == null || forNextStatement.Step.IsNull) { // range only goes to end - 1, so increment end end = Expression.AddInteger(end, 1); fs.Iterator = MakeMethodCall("range", start, ConvertExpression(end)); } else { PrimitiveExpression stepPE = forNextStatement.Step as PrimitiveExpression; if (stepPE == null || !(stepPE.Value is int)) { AddError(forNextStatement, "Step must be an integer literal"); } else { if ((int)stepPE.Value < 0) { end = Expression.AddInteger(end, -1); } else { end = Expression.AddInteger(end, 1); } } fs.Iterator = MakeMethodCall("range", start, ConvertExpression(end), ConvertExpression(forNextStatement.Step)); } return(fs); }
public object VisitMemberReferenceExpression(MemberReferenceExpression mre, object data) { B.Expression target = null; if (mre.TargetObject is TypeReferenceExpression) { // not typeof, so this is something like int.Parse() or Class<string>.StaticMethod TypeReference typeRef = ((TypeReferenceExpression)mre.TargetObject).TypeReference; if (!typeRef.IsArrayType) { target = MakeReferenceExpression(typeRef); } } if (target == null) { target = (B.Expression)mre.TargetObject.AcceptVisitor(this, data); if (target == null) { return(null); } } return(new B.MemberReferenceExpression(GetLexicalInfo(mre), target, mre.MemberName)); }
protected static AST.Expression output_binding(AST.Expression vname, AST.Expression expr) { AST.BlockExpression condition = new AST.BlockExpression(); condition.Body.Add(new AST.ReturnStatement(expr)); return(new AST.MethodInvocationExpression(new AST.ReferenceExpression("add_output_binding"), vname, condition, new AST.StringLiteralExpression(expr.ToCodeString()))); }
public static Expression Lift(Expression e) { if (e == null) return null; return e.CloneNode(); }
protected static AST.Expression task_output_data(AST.Expression expr) { AST.BlockExpression condition = new AST.BlockExpression(); condition.Body.Add(new AST.ReturnStatement(expr)); return(new AST.MethodInvocationExpression(new AST.ReferenceExpression("output_bindings_code"), condition, new AST.StringLiteralExpression(expr.ToCodeString()))); }
public static AST.Expression default_value(AST.Expression expr) { AST.BlockExpression condition = new AST.BlockExpression(); condition.Body.Add(new AST.ReturnStatement(expr)); return(new AST.MethodInvocationExpression(new AST.ReferenceExpression("variable_default"), condition, new AST.StringLiteralExpression(expr.ToCodeString()))); }
public object VisitSwitchSection(SwitchSection switchSection, object data) { B.IfStatement surroundingIf = (B.IfStatement)data; bool isDefault = false; ArrayList conditions = new ArrayList(); ArrayList labels = new ArrayList(); foreach (CaseLabel caseLabel in switchSection.SwitchLabels) { if (caseLabel.IsDefault) { isDefault = true; } else { if (caseLabel.BinaryOperatorType != BinaryOperatorType.None) { AddError(caseLabel, "VB's Case Is currently not supported (Daniel's too lazy for VB stuff)"); } else { B.Expression expr = ConvertExpression(caseLabel.Label); if (expr != null) { conditions.Add(new B.BinaryExpression(B.BinaryOperatorType.Equality, new B.ReferenceExpression(currentSwitchTempName), expr)); string labelName = expr.ToCodeString().GetHashCode().ToString(System.Globalization.NumberFormatInfo.InvariantInfo); labels.Add(MakeLabel(currentSwitchTempName + "_" + labelName)); } } } } B.IfStatement s = null; if (conditions.Count > 0) { s = new B.IfStatement(GetLexicalInfo(switchSection)); if (surroundingIf != null) { s.FalseBlock = surroundingIf.FalseBlock; surroundingIf.FalseBlock = new B.Block(); surroundingIf.FalseBlock.Add(s); } s.TrueBlock = new B.Block(); foreach (B.Statement stmt in labels) { s.TrueBlock.Add(stmt); } B.Expression combined = (B.Expression)conditions[0]; for (int i = 1; i < conditions.Count; i++) { combined = new B.BinaryExpression(B.BinaryOperatorType.Or, combined, (B.Expression)conditions[i]); } s.Condition = combined; foreach (Statement node in switchSection.Children) { AddToBlock(node, s.TrueBlock); } } if (s == null) { s = surroundingIf; } if (isDefault) { if (s.FalseBlock == null) { s.FalseBlock = new B.Block(); } s.FalseBlock.Add(MakeLabel(currentSwitchTempName + "_default")); foreach (Statement node in switchSection.Children) { AddToBlock(node, s.FalseBlock); } } return(s); }
protected void init_parameter(AST.Expression pref, AST.Expression expr) { }
public static AST.Expression when(AST.Expression expr) { AST.BlockExpression condition = new AST.BlockExpression(); condition.Body.Add(new AST.ReturnStatement(expr)); return(new AST.MethodInvocationExpression(new AST.ReferenceExpression("flow_condition"), condition, new AST.StringLiteralExpression(expr.ToCodeString()))); }
protected static AST.Expression multi_instance_split(AST.Expression expr) { AST.BlockExpression condition = new AST.BlockExpression(); condition.Body.Add(new AST.ReturnStatement(expr)); return(new AST.MethodInvocationExpression(new AST.ReferenceExpression("multi_instance_split_expression"), condition, new AST.StringLiteralExpression(expr.ToCodeString()))); }