private void RenderNamedConstructor(ConstructorNode n) { // Render the args type RenderNamedArgsType(n); RenderAttributes(n); _visitor.Visit(n.AccessModifier ?? new KeywordNode("private")); _renderer.Append(" "); _visitor.Visit(n.ClassName); _renderer.Append("(__ctorArgs_"); _visitor.Visit(n.Name); _renderer.Append(" __args)"); RenderThisArgs(n); _renderer.AppendLineAndIndent(); _renderer.Append("{"); _renderer.IncreaseIndent(); _renderer.AppendLineAndIndent(); foreach (var param in n.Parameters) { _renderer.Append("var "); _visitor.Visit(param.Name); _renderer.Append(" = __args."); _visitor.Visit(param.Name); _renderer.AppendLineAndIndent(";"); } RenderStatements(n); _renderer.DecreaseIndent(); _renderer.AppendLineAndIndent(); _renderer.Append("}"); }
public void TranslateConstructorNode(ConstructorNode node) { if (!node.IsPure) { // Translate all the pure nodes this node depends on in // the correct order TranslateDependentPureNodes(node); } // Write assignment and constructor string returnName = GetOrCreatePinName(node.OutputDataPins[0]); builder.Append($"{returnName} = new {node.ClassType}"); // Write constructor arguments var argumentNames = GetPinIncomingValues(node.ArgumentPins); builder.AppendLine($"({string.Join(", ", argumentNames)});"); if (!node.IsPure) { // Go to the next state WriteGotoOutputPinIfNecessary(node.OutputExecPins[0], node.InputExecPins[0]); } }
public static ConstructorNode PopulateTypes(this ConstructorNode node) { if (node == null || node.Constructor == null) { return(node); } ParameterInfo[] methodParams = node.Constructor.GetParameters(); if (node.Inputs.Count != methodParams.Length) { return(node); } for (int i = 0; i < methodParams.Length; i++) { node.Inputs[i].DataType = methodParams[i].ParameterType; if (methodParams[i].HasDefaultValue) { node.Inputs[i].DefaultValue = methodParams[i].DefaultValue; } } if (node.Outputs.Count > 0) { node.Outputs[0].DataType = node.Constructor.DeclaringType; } return(node); }
private void RenderAttributes(ConstructorNode n) { if (!n.Attributes.IsNullOrEmpty()) { foreach (var a in n.Attributes) { _visitor.Visit(a); } } }
public virtual AstNode VisitConstructor(ConstructorNode n) { Visit(n.Attributes); Visit(n.ClassName); Visit(n.AccessModifier); Visit(n.Parameters); Visit(n.ThisArgs); Visit(n.Statements); return(n); }
protected void WalkConstructorNode(ConstructorNode node) { if (node == null) { return; } node.Parameters?.ForEach(p => VisitParameterNode(p)); VisitMethodBody(node.Body); }
public void CanCreatePublicInstance() { ConstructorNode ctorNode = new ConstructorNode(typeof(PublicTestClass)); StringLiteralNode sNode = new StringLiteralNode("theValue"); ctorNode.AddArgument(sNode); PublicTestClass instance = (PublicTestClass) ((IExpression)ctorNode).GetValue(); Assert.AreEqual( sNode.Text, instance._s ); Assert.AreEqual( -1, instance._i ); }
private static Expression ConstructorMakeExpression( IList <Expression> expressions, VaribalesCollection variables, ConstructorNode constructor, Expression ifNull) { var args = constructor.Parameters.Select(argument => CreateVariableExpressions(expressions, variables, argument, ifNull)) .ToList(); return(Expression.New(constructor.Constructor, args)); }
public void CanCreatePublicInstance() { ConstructorNode ctorNode = new ConstructorNode(typeof(PublicTestClass)); StringLiteralNode sNode = new StringLiteralNode("theValue"); ctorNode.AddArgument(sNode); PublicTestClass instance = (PublicTestClass)((IExpression)ctorNode).GetValue(); Assert.AreEqual(sNode.Text, instance._s); Assert.AreEqual(-1, instance._i); }
public override void Visit(ConstructorNode node) { symbolTable.OpenScope(); node.FormalParamNodes?.ForEach(x => x.Accept(this)); node.Block.Accept(this); GetReturnNodes(node.Block).ForEach(returnNode => { if (returnNode.ReturnValue != null) { throw new SemanticException($"Error on line {node.line}: Return type invalid. Expected void, found {returnNode.ReturnValue.Type}."); } }); symbolTable.CloseScope(); }
private void RenderStatements(ConstructorNode n) { _renderer.AppendLineAndIndent("// Do not allow concrete inheritance"); _renderer.AppendLineAndIndent("System.Diagnostics.Debug.Assert(GetType().BaseType == typeof(object));"); foreach (var s in n.Statements.OrEmptyIfNull()) { _visitor.Visit(s); _renderer.AppendLineAndIndent(";"); _renderer.AppendLineAndIndent($"#line {s.Location.Line} \"{s.Location.FileName}\""); _renderer.AppendLineAndIndent(); } }
private void RenderNormalParameters(ConstructorNode n) { _renderer.Append("("); if (!n.Parameters.IsNullOrEmpty()) { _visitor.Visit(n.Parameters[0]); for (var i = 1; i < n.Parameters.Count; i++) { _renderer.Append(", "); _visitor.Visit(n.Parameters[i]); } } _renderer.Append(")"); }
public void CanCreatePublicInstanceWithNonPublicConstructor() { ConstructorNode ctorNode = new ConstructorNode(); ctorNode.Text=typeof(PublicTestClass).FullName; StringLiteralNode sNode = new StringLiteralNode(); sNode.Text = "theValue2"; ctorNode.addChild(sNode); IntLiteralNode iNode = new IntLiteralNode(); iNode.Text="2"; ctorNode.addChild(iNode); PublicTestClass instance = (PublicTestClass) ((IExpression)ctorNode).GetValue(); Assert.AreEqual( sNode.Text, instance._s ); Assert.AreEqual( 2, instance._i ); }
public override void Visit(ConstructorNode node) { Console.Write(" "); node.Id.Accept(this); Console.Write(" ("); node.FormalParamNodes?.ForEach(x => { if (node.FormalParamNodes.IndexOf(x) != 0) { Console.Write(", "); } x.Accept(this); }); Console.Write(")"); node.Block.Accept(this); }
public override void Visit(ConstructorNode node) { CSharpString.Append("public "); node.Id.Accept(this); CSharpString.Append(" ("); node.FormalParamNodes?.ForEach(x => { if (node.FormalParamNodes.IndexOf(x) != 0) { CSharpString.Append(", "); } x.Accept(this); }); CSharpString.Append(")"); node.Block.Accept(this); }
public void Render(ConstructorNode n) { if (n.Name == null) { RenderUnnamedConstructor(n); return; } if (n.Name != null) { RenderNamedConstructor(n); return; } throw new CSharpTranspileException("Could not render ConstructorNode"); }
protected override void VisitConstructorNode(string name, ConstructorNode node) { if (string.IsNullOrWhiteSpace(name) || node == null) { return; } AppendIndentation(); Append(node.Visibility); Append(name); Append("("); if (node.Parameters != null) { var isFirst = true; foreach (var p in node.Parameters) { if (!isFirst) { Append(", "); } VisitParameterNode(p); isFirst = false; } } Append(")"); AppendLine(); AppendLine("{"); ++this.indentLevel; VisitMethodBody(node.Body); --this.indentLevel; AppendLine("}"); AppendLine(); if (this.settings.BlankLine.Method) { AppendLine(); } }
private void RenderNamedArgsType(ConstructorNode n) { _renderer.Append("public class __ctorArgs_"); _visitor.Visit(n.Name); _renderer.AppendLineAndIndent(); _renderer.Append("{"); _renderer.IncreaseIndent(); _renderer.AppendLineAndIndent(); _renderer.Append("public __ctorArgs_"); _visitor.Visit(n.Name); RenderNormalParameters(n); _renderer.AppendLineAndIndent(); _renderer.Append("{"); _renderer.IncreaseIndent(); _renderer.AppendLineAndIndent(); foreach (var param in n.Parameters) { _renderer.Append("this."); _visitor.Visit(param.Name); _renderer.Append(" = "); _visitor.Visit(param.Name); _renderer.AppendLineAndIndent(";"); } _renderer.DecreaseIndent(); _renderer.AppendLineAndIndent(); _renderer.AppendLineAndIndent("}"); foreach (var param in n.Parameters) { _renderer.Append("public "); _visitor.Visit(param.Type); _renderer.Append(" "); _visitor.Visit(param.Name); _renderer.AppendLineAndIndent(" { get; private set; }"); } _renderer.DecreaseIndent(); _renderer.AppendLineAndIndent(); _renderer.AppendLineAndIndent("}"); _renderer.AppendLineAndIndent(); }
private static void ConstructorNextElement(IList <Expression> expressions, VaribalesCollection variables, Expression targetParameter, ConstructorNode constructor, Expression ifNull) { expressions.Add(Expression.Assign(targetParameter, ConstructorMakeExpression(expressions, variables, constructor, ifNull))); if (constructor.Type.IsValueType && !constructor.Type.IsNullable()) { return; } expressions.Add(Expression.IfThen( Expression.Equal(targetParameter, NullExpressionOf(constructor.Type)), ifNull)); }
private void RenderThisArgs(ConstructorNode n) { if (!n.ThisArgs.IsNullOrEmpty()) { _renderer.IncreaseIndent(); _renderer.AppendLineAndIndent(); _renderer.Append(": this("); _visitor.Visit(n.ThisArgs[0]); foreach (var a in n.ThisArgs.Skip(1)) { _renderer.Append(", "); _visitor.Visit(a); } _renderer.Append(")"); _renderer.DecreaseIndent(); } }
public void CanCreateNonPublicInstanceWithNonPublicConstructor() { ConstructorNode ctorNode = new ConstructorNode(); ctorNode.Text = typeof(PrivateTestClass).FullName; StringLiteralNode sNode = new StringLiteralNode(); sNode.Text = "theValue3"; ctorNode.addChild(sNode); IntLiteralNode iNode = new IntLiteralNode(); iNode.Text = "3"; ctorNode.addChild(iNode); PublicTestClass instance = (PublicTestClass)((IExpression)ctorNode).GetValue(); Assert.AreEqual(sNode.Text, instance._s); Assert.AreEqual(3, instance._i); }
private void RenderUnnamedConstructor(ConstructorNode n) { RenderAttributes(n); _visitor.Visit(n.AccessModifier ?? new KeywordNode("private")); _renderer.Append(" "); _visitor.Visit(n.ClassName); RenderNormalParameters(n); RenderThisArgs(n); _renderer.AppendLineAndIndent(); _renderer.Append("{"); _renderer.IncreaseIndent(); _renderer.AppendLineAndIndent(); RenderStatements(n); _renderer.DecreaseIndent(); _renderer.AppendLineAndIndent(); _renderer.Append("}"); }
void ConstructorDeclaration(Token encap, Token modifier, Token name, ref ClassNode clase) { printDebug("Constructor Declaration"); MatchExactly(new TokenType[] { TokenType.PAREN_OPEN }); var ctor = new ConstructorNode(new IdentifierNode(name), new EncapsulationNode(encap), modifier); var paremeters = FixedParameters(); MatchExactly(new TokenType[] { TokenType.PAREN_CLOSE }); var args = ConstructorInitializer(); var body = MaybeEmptyBlock(); ctor.body = body; ctor.parameters = paremeters; clase.constructors.Add(ctor); }
private ConstructorNode InnerPrepareConstructors(Generator generator, Dictionary <DefinitionTypeReference, KeyValuePair <Definition, List <Expression> > > irc, Definition parentDefinition) { ConstructorNode result = new ConstructorNode(); result.parentDefinition = parentDefinition; result.location = this; result.definition = ParentDefinition; result.runtimeStruct = generator.AllocateDataRegion(); result.parameters = parametersMetadata; result.statement = statementMetadata; if (anotherConstructorInstance != null) { result.redirect = new ConstructorNodeInvocation(anotherConstructor, anotherConstructorInstance.InnerPrepareConstructors(generator, irc, parentDefinition)); } else { result.inherit = new List <ConstructorNodeInvocation>(); foreach (DefinitionTypeReference e in ParentDefinition.Extends) { if (!irc.ContainsKey(e)) { continue; } KeyValuePair <Definition, List <Expression> > kv = irc[e]; if (kv.Key == ParentDefinition) { List <TypeReference> signature = new List <TypeReference>(); foreach (Expression a in kv.Value) { signature.Add(null); } // signature.Add(a.TypeReference); Constructor c = e.Definition.FindConstructor(this, new FunctionTypeReference(this, e, signature), generator.Resolver.CurrentDefinition); ConstructorNodeInvocation cni = new ConstructorNodeInvocation(kv.Value, c.InnerPrepareConstructors(generator, irc, parentDefinition)); result.inherit.Add(cni); } } } return(result); }
protected override void VisitConstructorNode(ConstructorNode node) { AppendIndentation(); AppendAccesType(node.Visibility); Append(_currentClassName); Append("("); if (node.Parameters != null) { var isFirst = true; foreach (var p in node.Parameters) { if (!isFirst) { Append(", "); } VisitParameterNode(p); isFirst = false; } } Append(")"); AppendLineEnding(); AppendLine("{"); ++_indentation; VisitMethodBody(node.Body); --_indentation; AppendLine("}"); AppendLineEnding(); }
/// <summary> /// Gets the tree. /// </summary> /// <param name="expression">The expression.</param> /// <param name="tree">The tree.</param> /// <param name="parent">The parent.</param> /// <returns></returns> /// <exception cref="ExpressionObserversException"> /// Expression member is not a PropertyInfo /// or /// Method call has no ReturnParameter /// or /// Expression body is null /// or /// Expression body is not a supportet Expression {expression} type {expression.Type} /// </exception> public static NodeCollection GetTree([NotNull] Expression expression, [NotNull] ITree tree, [CanBeNull] IExpressionNode parent) { if (expression == null) { throw new ArgumentNullException(nameof(expression)); } if (tree == null) { throw new ArgumentNullException(nameof(tree)); } var nodeCollection = new NodeCollection(tree, parent); while (true) { switch (expression) { case MemberExpression memberExpression when memberExpression.Member is PropertyInfo propertyInfo: { expression = memberExpression.Expression; nodeCollection.AddElement(new PropertyNode(memberExpression, propertyInfo)); break; } case MemberExpression memberExpression when memberExpression.Member is FieldInfo fieldInfo: expression = memberExpression.Expression; nodeCollection.AddElement(new FieldNode(memberExpression, fieldInfo)); break; case MemberExpression _: throw new ExpressionObserversException("Expression member is not a PropertyInfo"); case ParameterExpression parameterExpression: { var element = (new ParameterNode(parameterExpression)); nodeCollection.AddElement(element); nodeCollection.Roots.Add(element); return(nodeCollection); } case MethodCallExpression methodCallExpression when methodCallExpression.Method.ReturnParameter == null: throw new ExpressionObserversException("Method call has no ReturnParameter"); case MethodCallExpression methodCallExpression: expression = methodCallExpression.Object; if (expression != null) { var element = new MethodNode(methodCallExpression); element.Object = GetTree(expression, nodeCollection, element); var arguments = new List <NodeCollection>(); foreach (var argument in methodCallExpression.Arguments) { arguments.Add(GetTree(argument, nodeCollection, element)); } element.Arguments = arguments; nodeCollection.AddElement(element); return(nodeCollection); } else { var element = new FunctionNode(methodCallExpression); var parameters = new List <NodeCollection>(); foreach (var argument in methodCallExpression.Arguments) { parameters.Add(GetTree(argument, nodeCollection, element)); } element.Parameters = parameters; nodeCollection.AddElement(element); return(nodeCollection); } case ConstantExpression constantExpression: { var element = new ConstantNode(constantExpression); nodeCollection.AddElement(element); nodeCollection.Roots.Add(element); return(nodeCollection); } case BinaryExpression binaryExpression: { var element = new BinaryNode(binaryExpression); element.LeftNodes = GetTree(binaryExpression.Left, nodeCollection, element); element.Righttree = GetTree(binaryExpression.Right, nodeCollection, element); nodeCollection.AddElement(element); return(nodeCollection); } case UnaryExpression unaryExpression: { var element = new UnaryNode(unaryExpression); element.Operand = GetTree(unaryExpression.Operand, nodeCollection, element); nodeCollection.AddElement(element); return(nodeCollection); } case ConditionalExpression conditionalExpression: { var element = new ConditionalNode(conditionalExpression); element.Test = GetTree(conditionalExpression.Test, nodeCollection, element); element.IfTrue = GetTree(conditionalExpression.IfTrue, nodeCollection, element); element.IfFalse = GetTree(conditionalExpression.IfFalse, nodeCollection, element); nodeCollection.AddElement(element); return(nodeCollection); } case NewExpression newExpression: { var element = new ConstructorNode(newExpression); var parameters = new List <NodeCollection>(); foreach (var argument in newExpression.Arguments) { parameters.Add(GetTree(argument, nodeCollection, element)); } element.Parameters = parameters; nodeCollection.AddElement(element); return(nodeCollection); } case MemberInitExpression memberInitExpression: { var element = new MemberInitNode(memberInitExpression); var parameters = new List <NodeCollection>(); foreach (var argument in memberInitExpression.NewExpression.Arguments) { parameters.Add(GetTree(argument, nodeCollection, element)); } element.Parameters = parameters; var bindings = memberInitExpression.Bindings; var bindingtree = CreateBindingtree(nodeCollection, bindings, element); element.Bindings = bindingtree; nodeCollection.AddElement(element); return(nodeCollection); } case null: throw new ExpressionObserversException("Expression body is null"); default: throw new ExpressionObserversException( $"Expression body is not a supportet Expression {expression} type {expression.Type}"); } } }
static void ProcessConstructor(IASTNode constructor) { ConstructorNode constructorNode = (ConstructorNode)constructor; constructorNode.Prepare(); }
public void addContructor(ConstructorNode contructoreDeclaration) { this.Constructors.Add(contructoreDeclaration); }
public ConstructorNodeInvocation(List <Expression> arguments, ConstructorNode node) { this.node = node; this.arguments = arguments; Require.True(arguments.Count == node.parameters.ParameterList.Count); }
public void PrepareNestedConstructors(Generator generator) { Dictionary <DefinitionTypeReference, KeyValuePair <Definition, List <Expression> > > irc = InnerResolveConstructor(); rootConstructorNode = InnerPrepareConstructors(generator, irc, ParentDefinition); }
public AstNode VisitConstructor(ConstructorNode n) { new ConstructorNodeRenderer(this, _renderer).Render(n); return(n); }
protected void WalkConstructorNode(ConstructorNode node) { node.Parameters?.ForEach(p => VisitParameterNode(p)); VisitMethodBody(node.Body); }