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("}");
        }
Example #2
0
        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]);
            }
        }
Example #3
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);
         }
     }
 }
Example #5
0
 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 );
        }
Example #8
0
        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));
        }
Example #9
0
        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);
        }
Example #10
0
 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 );
        }
Example #14
0
 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");
        }
Example #17
0
        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();
        }
Example #19
0
        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();
            }
        }
Example #21
0
        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("}");
        }
Example #23
0
        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);
        }
Example #24
0
        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);
        }
Example #25
0
        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();
        }
Example #26
0
        /// <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}");
                }
            }
        }
Example #27
0
        static void ProcessConstructor(IASTNode constructor)
        {
            ConstructorNode constructorNode = (ConstructorNode)constructor;

            constructorNode.Prepare();
        }
Example #28
0
 public void addContructor(ConstructorNode contructoreDeclaration)
 {
     this.Constructors.Add(contructoreDeclaration);
 }
Example #29
0
 public ConstructorNodeInvocation(List <Expression> arguments, ConstructorNode node)
 {
     this.node      = node;
     this.arguments = arguments;
     Require.True(arguments.Count == node.parameters.ParameterList.Count);
 }
Example #30
0
        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);
 }
Example #32
0
 protected void WalkConstructorNode(ConstructorNode node)
 {
     node.Parameters?.ForEach(p => VisitParameterNode(p));
     VisitMethodBody(node.Body);
 }