private void AddVariables()
        {
            PrintDebugRessourcesBefore("AddVariables");

            var vb = new VariableBuilder(solverData);

            vb.CreateVariables();

            PrintDebugRessourcesAfter();
        }
예제 #2
0
        public IErrorReporter ErrorAccessNotGranted()
        {
            NameResolver resolver = null;
            foreach (var mutability in Options.AllMutabilityModes)
            {
                var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability));
                var root_ns = env.Root;

                NameReference forbidden_access = NameReference.CreateThised("x");

                VariableDeclaration decl = VariableBuilder.CreateStatement("y", NameFactory.Int64NameReference(), null)
                        .Modifier(EntityModifier.Public | env.Options.ReassignableModifier())
                        .GrantAccess("twin");

                root_ns.AddBuilder(TypeBuilder.Create("Point")
                    .SetModifier(EntityModifier.Mutable)
                    .With(FunctionBuilder.Create("friendly",
                        NameFactory.UnitNameReference(),
                        Block.CreateStatement( ExpressionFactory.Readout(NameFactory.ThisVariableName, "x"))))

                        .With(FunctionBuilder.Create("foe",
                            NameFactory.UnitNameReference(),
                            Block.CreateStatement( ExpressionFactory.Readout(forbidden_access))))

                        .With(FunctionBuilder.Create("twin",
                            NameFactory.UnitNameReference(),
                            Block.CreateStatement()))

                        .With(FunctionBuilder.Create("twin",
                            NameFactory.UnitNameReference(),
                            Block.CreateStatement(Return.Create(NameReference.Create("p"))))
                            .Parameters(FunctionParameter.Create("p", NameFactory.UnitNameReference())))

                        .With(VariableBuilder.CreateStatement("x", NameFactory.Int64NameReference(), null)
                        .Modifier(EntityModifier.Private | env.Options.ReassignableModifier())
                        .GrantAccess("friendly"))

                        .With(decl));

                resolver = NameResolver.Create(env);

                Assert.AreEqual(3, resolver.ErrorManager.Errors.Count);
                Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AccessForbidden, forbidden_access));
                Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AmbiguousReference, decl.AccessGrants.Single()));
                Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AccessGrantsOnExposedMember, decl.AccessGrants.Single()));
            }

            return resolver;
        }
            /// <summary>
            /// Push variable from <see cref="VariableBuilder"/> to <see cref="ExpressionsStack"/>.
            /// </summary>
            internal void PushVariable()
            {
                if (VariableBuilder.Length <= 0)
                {
                    return;
                }

                var variablevalue = VariableBuilder.ToString();
                var variable      = _expressionFactory.GetVariable(variablevalue);

                if (variable == null)
                {
                    throw new InvalidFormulaException(_formula, $"cannot parse variable '{variablevalue}'");
                }
                ExpressionsStack.Push(new VariableExpressionsGroup(variable));
                VariableBuilder.Clear();
            }