public IErrorReporter ErrorIsSameOnValues() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; Int64Literal value = Int64Literal.Create("3"); root_ns.AddBuilder(FunctionBuilder.Create("foo", NameFactory.BoolNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("x", null, ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("2"))), Return.Create(IsSame.Create(NameReference.Create("x"), value)) ))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotUseValueExpression, value)); } return(resolver); }
public IErrorReporter ErrorIsTypeAlienSealed() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.CreateInterface("IWhat")); root_ns.AddBuilder(TypeBuilder.Create("What") .Parents("IWhat")); // comparison does not make sense, because string is sealed and it is not possible to be given interface IsType is_type = IsType.Create(NameReference.Create("x"), NameFactory.StringNameReference()); root_ns.AddBuilder(FunctionBuilder.Create("foo", NameFactory.BoolNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("x", NameFactory.PointerNameReference("IWhat"), Undef.Create()), Return.Create(is_type) ))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, is_type)); } return(resolver); }
public IErrorReporter ScopeShadowing() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { ScopeShadowing = true, DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(FunctionBuilder.Create( "anything", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new IExpression[] { VariableDeclaration.CreateStatement("x",null,Int64Literal.Create("2")), Block.CreateStatement(new IExpression[]{ // shadowing VariableDeclaration.CreateStatement("x", null, BoolLiteral.CreateFalse()), VariableDeclaration.CreateStatement("a",NameFactory.BoolNameReference(),NameReference.Create("x")), ExpressionFactory.Readout("a"), }), VariableDeclaration.CreateStatement("b",NameFactory.Int64NameReference(),NameReference.Create("x")), ExpressionFactory.Readout("b"), }))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return resolver; }
public IErrorReporter ErrorUnusedExpression() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; var system_ns = env.SystemNamespace; var var_decl = VariableDeclaration.CreateStatement("x", NameFactory.BoolNameReference(), Undef.Create()); var var_ref = NameReference.Create("x"); FunctionDefinition func_def = root_ns.AddBuilder(FunctionBuilder.Create( "foo", ExpressionReadMode.OptionalUse, NameFactory.BoolNameReference(), Block.CreateStatement(new IExpression[] { var_decl, var_ref, Return.Create(BoolLiteral.CreateTrue()) }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.AreEqual(ErrorCode.ExpressionValueNotUsed, resolver.ErrorManager.Errors.Single().Code); Assert.AreEqual(var_ref, resolver.ErrorManager.Errors.Single().Node); } return(resolver); }
public IErrorReporter ErrorSelfAssignment() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; var system_ns = env.SystemNamespace; root_ns.AddBuilder(TypeBuilder.Create("Oint") .SetModifier(EntityModifier.Mutable) .With(Property.Create(env.Options, "x", NameFactory.Int64NameReference(), new[] { Property.CreateAutoField(NameFactory.PropertyAutoField, NameFactory.Int64NameReference(), null, env.Options.ReassignableModifier()) }, new[] { Property.CreateAutoGetter(NameFactory.PropertyAutoField, NameFactory.Int64NameReference()) }, new[] { Property.CreateAutoSetter(NameFactory.PropertyAutoField, NameFactory.Int64NameReference()) }))); var var_decl = VariableDeclaration.CreateStatement("x", NameFactory.BoolNameReference(), Undef.Create(), env.Options.ReassignableModifier()); IExpression assign_var = Assignment.CreateStatement(NameReference.Create("x"), NameReference.Create("x")); IExpression assign_prop = Assignment.CreateStatement(NameReference.Create("a", "x"), NameReference.Create("a", "x")); root_ns.AddBuilder(FunctionBuilder.Create( "foo", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new IExpression[] { var_decl, assign_var, VariableDeclaration.CreateStatement("a", null, ExpressionFactory.StackConstructor("Oint")), VariableDeclaration.CreateStatement("b", null, ExpressionFactory.StackConstructor("Oint")), Assignment.CreateStatement(NameReference.Create("a", "x"), NameReference.Create("b", "x")), assign_prop, }))); resolver = NameResolver.Create(env); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.SelfAssignment, assign_var)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.SelfAssignment, assign_prop)); } return(resolver); }
private IErrorReporter duckTyping(Options options) { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(options.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("IX") .With(FunctionBuilder.CreateDeclaration( "bar", ExpressionReadMode.OptionalUse, NameFactory.PointerNameReference(NameFactory.IObjectNameReference())) .Parameters(FunctionParameter.Create("x", NameFactory.BoolNameReference(), Variadic.None, null, isNameRequired: false))) .SetModifier(env.Options.InterfaceDuckTyping ? EntityModifier.Interface : EntityModifier.Protocol)); root_ns.AddBuilder(TypeBuilder.Create("X") .With(FunctionBuilder.Create("bar", ExpressionReadMode.OptionalUse, // subtype of original result typename -- this is legal NameFactory.PointerNameReference(NameFactory.Int64NameReference()), Block.CreateStatement(new[] { Return.Create(ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("2"))) })) .Parameters(FunctionParameter.Create("x", NameFactory.BoolNameReference(), usageMode: ExpressionReadMode.CannotBeRead)))); root_ns.AddBuilder(FunctionBuilder.Create( "main", ExpressionReadMode.OptionalUse, NameFactory.Int64NameReference(), Block.CreateStatement(new IExpression[] { VariableDeclaration.CreateStatement("i", NameFactory.PointerNameReference(NameReference.Create("IX")), null, env.Options.ReassignableModifier()), Assignment.CreateStatement(NameReference.Create("i"), ExpressionFactory.HeapConstructor(NameReference.Create("X"))), ExpressionFactory.Readout("i"), Return.Create(Int64Literal.Create("2")) }))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IInterpreter ResolvingGenericArgumentInRuntime() { var interpreter = new Interpreter.Interpreter(); foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { DebugThrowOnError = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(FunctionBuilder.Create("oracle", "O", VarianceMode.None, NameFactory.BoolNameReference(), Block.CreateStatement( Return.Create(IsType.Create(NameReference.Create("thing"), NameReference.Create("O"))) )) .Parameters(FunctionParameter.Create("thing", NameFactory.ReferenceNameReference(NameFactory.IObjectNameReference())))); root_ns.AddBuilder(FunctionBuilder.Create( "main", ExpressionReadMode.OptionalUse, NameFactory.Nat8NameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("acc", null, Nat8Literal.Create("0"), env.Options.ReassignableModifier()), VariableDeclaration.CreateStatement("i", null, ExpressionFactory.HeapConstructor(NameFactory.IntNameReference(), IntLiteral.Create("7"))), VariableDeclaration.CreateStatement("d", null, ExpressionFactory.HeapConstructor(NameFactory.RealNameReference(), RealLiteral.Create("3.3"))), IfBranch.CreateIf(FunctionCall.Create(NameReference.Create("oracle", NameFactory.IntNameReference()), NameReference.Create("i")), new[] { ExpressionFactory.IncBy("acc", Nat8Literal.Create("2")) }), IfBranch.CreateIf(FunctionCall.Create(NameReference.Create("oracle", NameFactory.IntNameReference()), NameReference.Create("d")), new[] { ExpressionFactory.IncBy("acc", Nat8Literal.Create("88")) }), Return.Create(NameReference.Create("acc")) ))); ExecValue result = interpreter.TestRun(env); Assert.AreEqual((byte)2, result.RetValue.PlainValue); } return(interpreter); }
public IErrorReporter ErrorIfScope() { 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 bad_ref = NameReference.Create("x"); root_ns.AddBuilder(FunctionBuilder.Create( "testing", NameFactory.UnitNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("b", NameFactory.BoolNameReference(), Undef.Create(), env.Options.ReassignableModifier()), IfBranch.CreateIf(VariableDeclaration.CreateExpression("x", null, BoolLiteral.CreateTrue()), // x is in scope Assignment.CreateStatement("b", "x"), IfBranch.CreateElse( // x is in scope as well Assignment.CreateStatement("b", "x"))), // here x is not in the scope (is already removed) Assignment.CreateStatement(NameReference.Create("b"), bad_ref), ExpressionFactory.Readout("b") ))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ReferenceNotFound, bad_ref)); } return(resolver); }
public IErrorReporter ErrorInvalidConverters() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; FunctionDefinition conv1 = FunctionBuilder.Create(NameFactory.ConvertFunctionName, NameFactory.Int64NameReference(), Block.CreateStatement(Return.Create(Int64Literal.Create("3")))); FunctionDefinition conv2 = FunctionBuilder.Create(NameFactory.ConvertFunctionName, ExpressionReadMode.OptionalUse, NameFactory.BoolNameReference(), Block.CreateStatement(Return.Create(Undef.Create()))) .SetModifier(EntityModifier.Pinned); FunctionDefinition conv3 = FunctionBuilder.Create(NameFactory.ConvertFunctionName, NameFactory.StringPointerNameReference(), Block.CreateStatement(Return.Create(Undef.Create()))) .SetModifier(EntityModifier.Pinned) .Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead)); root_ns.AddBuilder(TypeBuilder.Create("Start") .SetModifier(EntityModifier.Base) .With(conv1) .With(conv2) .With(conv3)); resolver = NameResolver.Create(env); Assert.AreEqual(3, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ConverterNotPinned, conv1)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ConverterDeclaredWithIgnoredOutput, conv2)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ConverterWithParameters, conv3)); } return(resolver); }
/*private TypeBuilder WithBaseEnum(string typename) * { * if (this.build != null) * throw new InvalidOperationException(); * * NameReference typename_ref = NameReference.Create(typename); * this.embedTypeNames.Add(typename_ref); * this.With(FunctionDefinition.CreateInitConstructor(EntityModifier.Native | EntityModifier.Implicit, * new[] { FunctionParameter.Create(NameFactory.SourceConvConstructorParameter, typename_ref, * ExpressionReadMode.CannotBeRead) }, * Block.CreateStatement())); * * return this; * }*/ public static TypeBuilder CreateEnum(string name) { TypeBuilder builder = new TypeBuilder(NameDefinition.Create(name)); builder = builder .SetModifier(EntityModifier.Enum) .Parents(NameFactory.IEquatableNameReference()) .With(FunctionDefinition.CreateInitConstructor(EntityModifier.Native | EntityModifier.Private, new[] { FunctionParameter.Create(NameFactory.EnumConstructorParameter, NameFactory.NatNameReference(), ExpressionReadMode.CannotBeRead) }, Block.CreateStatement())) // copy constructor .With(FunctionDefinition.CreateInitConstructor(EntityModifier.Native, new[] { FunctionParameter.Create(NameFactory.SourceCopyConstructorParameter, NameReference.Create(name), ExpressionReadMode.CannotBeRead) }, Block.CreateStatement())) .With(FunctionBuilder.Create(NameFactory.ConvertFunctionName, ExpressionReadMode.ReadRequired, NameFactory.NatNameReference(), Block.CreateStatement()) .SetModifier(EntityModifier.Native)) // when enum inherits an enum it won't call super to check equality .WithEquatableEquals(EntityModifier.UnchainBase) .With(FunctionBuilder.Create(NameFactory.EqualOperator, ExpressionReadMode.ReadRequired, NameFactory.BoolNameReference(), Block.CreateStatement(new[] { Return.Create(Undef.Create()) })) .SetModifier(EntityModifier.Native) .Parameters(FunctionParameter.Create("cmp", builder.CreateTypeNameReference(TypeMutability.ReadOnly), ExpressionReadMode.CannotBeRead))) .With(FunctionBuilder.Create(NameFactory.NotEqualOperator, ExpressionReadMode.ReadRequired, NameFactory.BoolNameReference(), Block.CreateStatement(new[] { Return.Create(Undef.Create()) })) .SetModifier(EntityModifier.Native) .Parameters(FunctionParameter.Create("cmp", builder.CreateTypeNameReference(TypeMutability.ReadOnly), ExpressionReadMode.CannotBeRead))) ; return(builder); }
public IErrorReporter ProperBasicMethodOverride() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("IX") .With(FunctionBuilder.CreateDeclaration( "bar", ExpressionReadMode.OptionalUse, NameFactory.PointerNameReference(NameFactory.IObjectNameReference())) .Parameters(FunctionParameter.Create("x", NameFactory.BoolNameReference(), Variadic.None, null, isNameRequired: false))) .SetModifier(EntityModifier.Interface)); TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create("X") .With(FunctionBuilder.Create("bar", ExpressionReadMode.OptionalUse, // subtype of original result typename -- this is legal NameFactory.PointerNameReference(NameFactory.Int64NameReference()), Block.CreateStatement(new[] { Return.Create(ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("2"))) })) .Parameters(FunctionParameter.Create("x", NameFactory.BoolNameReference(), usageMode: ExpressionReadMode.CannotBeRead)) .SetModifier(EntityModifier.Override)) .Parents(NameReference.Create("IX"))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorMixingSlicingTypes() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true, AllowProtocols = true }.SetMutability(mutability)); var root_ns = env.Root; var system_ns = env.SystemNamespace; INameReference typename = NameReferenceUnion.Create(new[] { NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()), NameFactory.BoolNameReference() }); var decl = VariableDeclaration.CreateStatement("foo", typename, initValue: Undef.Create()); var func_def_void = root_ns.AddBuilder(FunctionBuilder.Create( "notimportant", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { decl, ExpressionFactory.Readout("foo") }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MixingSlicingTypes, typename)); } return(resolver); }
public IErrorReporter ErrorCastingToSet() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true, AllowProtocols = true }.SetMutability(mutability)); var root_ns = env.Root; NameReferenceUnion type_set = NameReferenceUnion.Create( NameFactory.PointerNameReference(NameFactory.BoolNameReference()), NameFactory.PointerNameReference(NameFactory.Int64NameReference())); root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { VariableDeclaration.CreateStatement("x", NameFactory.IObjectNameReference(), Undef.Create()), VariableDeclaration.CreateStatement("c", null, ExpressionFactory.DownCast(NameReference.Create("x"), type_set)), ExpressionFactory.Readout("c"), }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TestingAgainstTypeSet, type_set)); } return(resolver); }
public IErrorReporter ErrorReadingFunctionVoidResult() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { GlobalVariables = true, RelaxedMode = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(FunctionBuilder.Create( "foo", ExpressionReadMode.CannotBeRead, NameFactory.BoolNameReference(), Block.CreateStatement(new[] { Return.Create(BoolLiteral.CreateTrue()) })) .Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), usageMode: ExpressionReadMode.CannotBeRead))); root_ns.AddNode(VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), Undef.Create())); var call = FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(NameReference.Create("i"))); VariableDeclaration decl = VariableDeclaration.CreateStatement("x", NameFactory.BoolNameReference(), call, EntityModifier.Public); root_ns.AddNode(decl); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotReadExpression, call)); } return(resolver); }
public IErrorReporter ErrorCompoundDefaultValue() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { GlobalVariables = true, RelaxedMode = true, AllowProtocols = true }.SetMutability(mutability)); var root_ns = env.Root; var decl = root_ns.AddNode(VariableDeclaration.CreateStatement("x", NameReferenceUnion.Create( new[] { NameFactory.PointerNameReference(NameFactory.BoolNameReference()), NameFactory.PointerNameReference(NameFactory.Int64NameReference()) }), initValue: null, modifier: EntityModifier.Public)); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotAutoInitializeCompoundType, decl)); } return(resolver); }
public IInterpreter DereferenceOnIfCondition() { var interpreter = new Interpreter.Interpreter(); foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DebugThrowOnError = true, AllowInvalidMainResult = true }.SetMutability(mutability)); var root_ns = env.Root; var main_func = root_ns.AddBuilder(FunctionBuilder.Create( "main", ExpressionReadMode.OptionalUse, NameFactory.Int64NameReference(), Block.CreateStatement(new IExpression[] { VariableDeclaration.CreateStatement("ptr", NameFactory.PointerNameReference(NameFactory.BoolNameReference()), ExpressionFactory.HeapConstructor(NameFactory.BoolNameReference(), FunctionArgument.Create(BoolLiteral.CreateTrue()))), Return.Create(IfBranch.CreateIf(NameReference.Create("ptr"), new[] { Int64Literal.Create("2") }, IfBranch.CreateElse(new[] { Int64Literal.Create("5") }))), }))); ExecValue result = interpreter.TestRun(env); Assert.AreEqual(2L, result.RetValue.PlainValue); } return(interpreter); }
public IErrorReporter TranslationTableOfInferredCommonTypes() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; TemplateParameter template_param = TemplateParametersBuffer.Create("T").Values.Single(); root_ns.AddBuilder(FunctionBuilder.Create("getMe", new[] { template_param }, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement()) .Parameters(FunctionParameter.Create("a", NameFactory.ReferenceNameReference("T"), ExpressionReadMode.CannotBeRead), FunctionParameter.Create("b", NameFactory.ReferenceNameReference("T"), ExpressionReadMode.CannotBeRead))); FunctionCall call = FunctionCall.Create(NameReference.Create("getMe"), NameReference.Create("x"), NameReference.Create("y")); root_ns.AddBuilder(FunctionBuilder.Create("common", NameFactory.UnitNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("x", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()), Int64Literal.Create("3")), VariableDeclaration.CreateStatement("y", NameFactory.ReferenceNameReference(NameFactory.BoolNameReference()), BoolLiteral.CreateTrue()), call ))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); // the actual point of this test are those two lines checking if we get correct translation table for entire // instance of the called function Assert.IsTrue(call.Resolution.TargetFunctionInstance.Translation.Translate(template_param, out IEntityInstance common_instance)); Assert.AreEqual(resolver.Context.Env.IEquatableType.InstanceOf, common_instance); } return(resolver); }
public static TypeBuilder WithEquatableEquals(this TypeBuilder builder, EntityModifier modifier = null) { return(builder.With(FunctionBuilder.Create(NameFactory.EqualOperator, ExpressionReadMode.ReadRequired, NameFactory.BoolNameReference(), Block.CreateStatement( IfBranch.CreateIf(IsSame.Create(NameReference.CreateThised(), NameReference.Create("cmp")), new[] { Return.Create(BoolLiteral.CreateTrue()) }), // let obj = cmp cast? Self VariableDeclaration.CreateStatement("obj", null, ExpressionFactory.CheckedSelfCast("cmp", NameFactory.ReferenceNameReference(builder.CreateTypeNameReference(TypeMutability.ReadOnly)))), // return this==obj.value Return.Create(ExpressionFactory.IsEqual(NameReference.Create(NameFactory.ThisVariableName), NameReference.Create("obj"))))) .SetModifier(EntityModifier.Override | modifier) .Parameters(FunctionParameter.Create("cmp", NameFactory.ReferenceNameReference(NameFactory.IEquatableNameReference(TypeMutability.ReadOnly)))))); }
public IInterpreter ShortcutComputationInOptionalDeclaration() { var interpreter = new Interpreter.Interpreter(); foreach (var mutability in Options.AllMutabilityModes) { // purpose: check if RHS of the optional declaration is computed only when it is needed // here we count RHS computations and since we declare two variables // let (x,y) =? (None,Some) // Some should not be executed, because `x` assigment fails first var env = Language.Environment.Create(new Options() { DebugThrowOnError = true, DiscardingAnyExpressionDuringTests = true, }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Mutator") .SetModifier(EntityModifier.Mutable) .With(VariableDeclaration.CreateStatement("c", NameFactory.IntNameReference(), null, env.Options.ReassignableModifier() | EntityModifier.Public))); // return Some or None depending on the `f` parameter, and also increments the count of option evaluations root_ns.AddBuilder(FunctionBuilder.Create("give", NameFactory.OptionNameReference(NameFactory.Nat8NameReference()), Block.CreateStatement( ExpressionFactory.Inc(() => NameReference.Create("m", "c")), Return.Create(ExpressionFactory.Ternary(NameReference.Create("f"), ExpressionFactory.OptionOf(NameFactory.Nat8NameReference(), Nat8Literal.Create("11")), ExpressionFactory.OptionEmpty(NameFactory.Nat8NameReference()))) )) .Parameters(FunctionParameter.Create("f", NameFactory.BoolNameReference()), FunctionParameter.Create("m", NameFactory.ReferenceNameReference(NameReference.Create("Mutator"))))); IExpression opt_declaration = ExpressionFactory.OptionalDeclaration(new[] { VariablePrototype.Create("x", NameFactory.Nat8NameReference()), VariablePrototype.Create("y", NameFactory.Nat8NameReference()) }, new[] { FunctionCall.Create("give", BoolLiteral.CreateFalse(), NameReference.Create("mut")), FunctionCall.Create("give", BoolLiteral.CreateTrue(), NameReference.Create("mut")), }); root_ns.AddBuilder(FunctionBuilder.Create("main", ExpressionReadMode.OptionalUse, NameFactory.Nat8NameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("mut", null, ExpressionFactory.StackConstructor(NameReference.Create("Mutator"))), IfBranch.CreateIf(opt_declaration, new[] { ExpressionFactory.Readout("x"), ExpressionFactory.Readout("y"), ExpressionFactory.GenericThrow(), }, IfBranch.CreateElse( // crucial check -- we should not evaluate the second option ExpressionFactory.AssertEqual(IntLiteral.Create("1"), NameReference.Create("mut", "c")) )), Return.Create(Nat8Literal.Create("0")) ))); ExecValue result = interpreter.TestRun(env); Assert.AreEqual((byte)0, result.RetValue.PlainValue); } return(interpreter); }
private BoolLiteral(bool value) : base(value ? "true" : "false", NameFactory.BoolNameReference( )) { this.Value = value; }