Beispiel #1
0
        public void ExpressionSplittingTest1()
        {
            var expr = new StatementList(MetaData.Empty,
                                         IdDeclaration,
                                         new ExpressionStatement(MetaData.Empty,
                                                                 new FunctionCallExpression(MetaData.Empty,
                                                                                            new VariableExpression(MetaData.Empty, "id"),
                                                                                            new List <Expression>(new[]
            {
                new FunctionCallExpression(MetaData.Empty,
                                           new VariableExpression(MetaData.Empty, "id"),
                                           new List <Expression>(new[]
                {
                    new FunctionCallExpression(MetaData.Empty,
                                               new VariableExpression(MetaData.Empty, "id"),
                                               new List <Expression>(new[]
                    {
                        new IntLiteralExpression(MetaData.Empty, "123", true)
                    })
                                               )
                }))
            }))));

            expr.SurroundWith(Environment.SolarSystem);
            expr.PrintDumpInfo();
            Assert.IsNotNull(expr.ConvertedStatementList);
            expr.ConvertedStatementList.PrintDumpInfo();
        }
Beispiel #2
0
        public void FuncCallTest4()
        {
            var lambda = new LambdaExpression(MetaData.Empty,
                                              new StatementList(MetaData.Empty,
                                                                new ReturnStatement(MetaData.Empty,
                                                                                    new FunctionCallExpression(MetaData.Empty,
                                                                                                               new VariableExpression(MetaData.Empty, "recur"),
                                                                                                               new List <Expression>(new[]
            {
                new VariableExpression(MetaData.Empty, "a")
            })))),
                                              new List <VariableDeclaration>(new[]
            {
                new VariableDeclaration(MetaData.Empty, "a", type:
                                        new UnknownType(MetaData.Empty, "i8"))
            }), new UnknownType(MetaData.Empty, "i8"));
            var example = new StatementList(MetaData.Empty,
                                            new VariableDeclaration(MetaData.Empty, "recurFunc",
                                                                    lambda),
                                            new VariableDeclaration(MetaData.Empty, "gg", isMutable: true, type:
                                                                    new UnknownType(MetaData.Empty, "i8")),
                                            new AssignmentStatement(MetaData.Empty,
                                                                    new VariableExpression(MetaData.Empty, "gg"),
                                                                    new FunctionCallExpression(MetaData.Empty,
                                                                                               new VariableExpression(MetaData.Empty, "recurFunc"),
                                                                                               new List <Expression>(new[]
            {
                new IntLiteralExpression(MetaData.Empty, "233", true, 8)
            }))));

            example.SurroundWith(Environment.SolarSystem);
            example.PrintDumpInfo();
        }
Beispiel #3
0
        public void TypeInferenceTest2()
        {
            const string varName = "someOtherVar";
            var          example = new StatementList(MetaData.Empty,
                                                     new VariableDeclaration(MetaData.Empty, varName,
                                                                             new NullExpression(MetaData.Empty)),
                                                     new ExpressionStatement(MetaData.Empty,
                                                                             new VariableExpression(MetaData.Empty, varName)));

            example.SurroundWith(Environment.SolarSystem);
            example.PrintDumpInfo();
            Assert.AreEqual(PrimaryType.NullType,
                            ((ExpressionStatement)example.Statements.Last())
                            .Expression.GetExpressionType().ToString());
        }
Beispiel #4
0
        public void TypeInferenceTest1()
        {
            const string varName = "someVar";
            var          example = new StatementList(MetaData.Empty,
                                                     new VariableDeclaration(MetaData.Empty, varName,
                                                                             new IntLiteralExpression(MetaData.Empty, "123", false, 8)),
                                                     new ExpressionStatement(MetaData.Empty,
                                                                             new VariableExpression(MetaData.Empty, varName)));

            example.SurroundWith(Environment.SolarSystem);
            example.PrintDumpInfo();
            // ReSharper disable once PossibleNullReferenceException
            Assert.AreEqual("u8", ((ExpressionStatement)example.Statements.Last())
                            .Expression.GetExpressionType().ToString());
        }
Beispiel #5
0
        public void FuncCallTest2()
        {
            var example = new StatementList(MetaData.Empty,
                                            IdDeclaration,
                                            new VariableDeclaration(MetaData.Empty, "gg", isMutable: true, type:
                                                                    new UnknownType(MetaData.Empty, "i8")),
                                            new AssignmentStatement(MetaData.Empty,
                                                                    new VariableExpression(MetaData.Empty, "gg"),
                                                                    new FunctionCallExpression(MetaData.Empty,
                                                                                               new VariableExpression(MetaData.Empty, "id"),
                                                                                               new List <Expression>(new[] { new IntLiteralExpression(MetaData.Empty, "233", true, 8) }))));

            example.SurroundWith(Environment.SolarSystem);
            example.PrintDumpInfo();
            Console.WriteLine(string.Join("\n", Errors.ErrList));
            Assert.IsTrue(0 == Errors.ErrList.Count);
        }
Beispiel #6
0
        public void StatementTest4()
        {
            const string var1 = "variableOne";
            var          stmt = new StatementList(MetaData.Empty,
                                                  new VariableDeclaration(MetaData.Empty, var1,
                                                                          new BoolLiteralExpression(MetaData.Empty, true), true),
                                                  new WhileStatement(MetaData.Empty,
                                                                     new VariableExpression(MetaData.Empty, var1),
                                                                     new StatementList(MetaData.Empty,
                                                                                       new AssignmentStatement(MetaData.Empty,
                                                                                                               new VariableExpression(MetaData.Empty, var1),
                                                                                                               new BoolLiteralExpression(MetaData.Empty, false)))));

            stmt.SurroundWith(Environment.SolarSystem);
            stmt.PrintDumpInfo();
            Assert.IsTrue(0 == Errors.ErrList.Count);
        }
Beispiel #7
0
        public void StructTest1()
        {
            var @struct = new StatementList(MetaData.Empty,
                                            new StructDeclaration(MetaData.Empty, "Person", new List <VariableDeclaration>(new[]
            {
                new VariableDeclaration(MetaData.Empty, "name", new StringLiteralExpression(MetaData.Empty, "ice")),
                new VariableDeclaration(MetaData.Empty, "gender",
                                        new IntLiteralExpression(MetaData.Empty, "123", false))
            })),
                                            new VariableDeclaration(MetaData.Empty, "var", type:
                                                                    new UnknownType(MetaData.Empty, "Person")));

            @struct.SurroundWith(Environment.SolarSystem);
            @struct.PrintDumpInfo();
            var a = (VariableDeclaration)@struct.Statements.Last();

            Assert.AreEqual("Person", a.Type.ToString());
            Assert.IsTrue(a.Type is SecondaryType);
        }