public IErrorReporter TypeTesting() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { GlobalVariables = true, RelaxedMode = true }.SetMutability(mutability)); var root_ns = env.Root; var system_ns = env.SystemNamespace; IsType is_type = IsType.Create(NameReference.Create("foo"), NameFactory.PointerNameReference(NameFactory.RealNameReference())); var decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.PointerNameReference(NameFactory.IObjectNameReference()), initValue: Undef.Create(), modifier: EntityModifier.Public); var decl_dst = VariableDeclaration.CreateStatement("bar", null, initValue: is_type, modifier: EntityModifier.Public); root_ns.AddNode(decl_src); root_ns.AddNode(decl_dst); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorDefaultUndef() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; Undef default_value = Undef.Create(); root_ns.AddBuilder(FunctionBuilder.Create( "foo", ExpressionReadMode.OptionalUse, NameFactory.RealNameReference(), Block.CreateStatement(new[] { Return.Create(RealLiteral.Create("3.3")) })) .Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), Variadic.None, default_value, false, usageMode: ExpressionReadMode.CannotBeRead))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.InitializationWithUndef, default_value)); } return(resolver); }
public IInterpreter TypeIntersection() { var interpreter = new Interpreter.Interpreter(); foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { AllowInvalidMainResult = true, DebugThrowOnError = true, AllowProtocols = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.CreateInterface("IGetPos") .With(FunctionBuilder.CreateDeclaration("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference()))); root_ns.AddBuilder(TypeBuilder.CreateInterface("IGetNeg") .With(FunctionBuilder.CreateDeclaration("getMore", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference()))); root_ns.AddBuilder(TypeBuilder.Create("GetAll") .Parents("IGetPos", "IGetNeg") .With(FunctionBuilder.Create("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new[] { Return.Create(Int64Literal.Create("3")) })) .SetModifier(EntityModifier.Override) ) .With(FunctionBuilder.Create("getMore", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new[] { Return.Create(Int64Literal.Create("-1")) })) .SetModifier(EntityModifier.Override) )); NameReferenceIntersection intersection = NameReferenceIntersection.Create( NameFactory.PointerNameReference(NameReference.Create("IGetNeg")), NameFactory.PointerNameReference(NameReference.Create("IGetPos"))); var main_func = root_ns.AddBuilder(FunctionBuilder.Create( "main", ExpressionReadMode.OptionalUse, NameFactory.Int64NameReference(), Block.CreateStatement(new IExpression[] { VariableDeclaration.CreateStatement("a", intersection, Undef.Create(), env.Options.ReassignableModifier()), VariableDeclaration.CreateStatement("b", intersection, Undef.Create(), env.Options.ReassignableModifier()), Assignment.CreateStatement(NameReference.Create("a"), ExpressionFactory.HeapConstructor("GetAll")), Assignment.CreateStatement(NameReference.Create("b"), ExpressionFactory.HeapConstructor("GetAll")), VariableDeclaration.CreateStatement("x", null, FunctionCall.Create(NameReference.Create("a", "getSome"))), VariableDeclaration.CreateStatement("y", null, FunctionCall.Create(NameReference.Create("b", "getMore"))), Return.Create(ExpressionFactory.Add(NameReference.Create("x"), NameReference.Create("y"))) }))); ExecValue result = interpreter.TestRun(env); Assert.AreEqual(2L, result.RetValue.PlainValue); } return(interpreter); }
public IErrorReporter ErrorAbusingForcedConst() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Stone")); root_ns.AddBuilder(TypeBuilder.Create("Mutator", "M") .With(FunctionBuilder.Create("violate", NameFactory.UnitNameReference(), Block.CreateStatement()) .SetModifier(EntityModifier.Mutable)) .SetModifier(EntityModifier.Mutable)); root_ns.AddBuilder(TypeBuilder.Create("Mangler") .SetModifier(EntityModifier.Mutable) .With(VariableDeclaration.CreateStatement("m", NameFactory.PointerNameReference(NameReference.Create("Mutator", NameReference.Create("Stone"))), Undef.Create(), EntityModifier.Public | env.Options.ReassignableModifier())) ); FunctionCall mut_call = FunctionCall.Create(NameReference.CreateThised("f", "m", NameFactory.MutableName("violate"))); IExpression assignment = Assignment.CreateStatement(NameReference.CreateThised("f", "m"), Undef.Create()); root_ns.AddBuilder(TypeBuilder.Create("Keeper") .With(VariableDeclaration.CreateStatement("f", NameFactory.PointerNameReference(NameReference.Create(TypeMutability.ForceConst, "Mangler")), Undef.Create(), EntityModifier.Public)) .With(FunctionBuilder.Create("testing", NameFactory.UnitNameReference(), Block.CreateStatement( mut_call, assignment )))); resolver = NameResolver.Create(env); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AlteringNonMutableInstance, mut_call)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AlteringNonMutableInstance, assignment)); } return(resolver); }
public IErrorReporter ErrorViolatingConstConstraint() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Bar") .SetModifier(EntityModifier.Mutable)); root_ns.AddBuilder(TypeBuilder.Create("Foo")); // we build type Point<T> with enforced "const" on T -- meaning we can pass only trully immutable types // as T VariableDeclaration field = VariableDeclaration.CreateStatement("m", NameReference.Create("T"), Undef.Create(), modifier: EntityModifier.Public); TypeDefinition point_type = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Point", TemplateParametersBuffer.Create().Add("T").Values)) .Constraints(ConstraintBuilder.Create("T") .SetModifier(EntityModifier.Const)) .With(field)); // Bar is mutable type, so we cannot construct Point<Bar> since Point requires immutable type NameReference wrong_type = NameReference.Create("Point", NameReference.Create("Bar")); var func_def = root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { VariableDeclaration.CreateStatement("x", NameReference.Create("Point", NameReference.Create("Foo")), Undef.Create()), VariableDeclaration.CreateStatement("y", wrong_type, Undef.Create()), ExpressionFactory.Readout("x"), ExpressionFactory.Readout("y"), }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ViolatedMutabilityConstraint, wrong_type)); } return(resolver); }
public IErrorReporter ErrorCastingWithMutabilityChange() { NameResolver resolver = null; foreach (var mutability in Options.StrictMutabilityModes) { var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Alien") .SetModifier(EntityModifier.Mutable)); // since Alien is mutable it looks like we try to shake off neutral flag IExpression bad_cast = ExpressionFactory.DownCast(NameReference.Create("x"), NameFactory.PointerNameReference(NameReference.Create("Alien"))); ReinterpretType bad_reinterpret = bad_cast.DescendantNodes().WhereType <ReinterpretType>().Single(); root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("x", NameFactory.PointerNameReference(NameFactory.IObjectNameReference(TypeMutability.ReadOnly)), Undef.Create()), VariableDeclaration.CreateStatement("c", null, bad_cast), ExpressionFactory.Readout("c"), VariableDeclaration.CreateStatement("ok", null, ExpressionFactory.DownCast(NameReference.Create("x"), NameFactory.PointerNameReference(NameReference.Create(TypeMutability.ReadOnly, "Alien")))), ExpressionFactory.Readout("ok") ))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, bad_reinterpret)); } return(resolver); }
public IErrorReporter ErrorEscapingReceivedReferenceFromGetter() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true } .SetMutability(mutability)); var root_ns = env.Root; Property property = PropertyBuilder.CreateReferential(env.Options, "meow", () => NameFactory.IntNameReference()) .WithAutoField(Undef.Create()) .WithAutoGetter(); root_ns.AddBuilder(TypeBuilder.Create("Keeper") .With(property)); NameReference heap_get_ref = NameReference.Create("h", "meow"); NameReference stack_get_ref = NameReference.Create("s", "meow"); FunctionDefinition func = root_ns.AddBuilder(FunctionBuilder.Create("notimportant", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("i", NameFactory.ReferenceNameReference(NameFactory.IntNameReference()), IntLiteral.Create("0"), EntityModifier.Reassignable), VariableDeclaration.CreateStatement("h", null, ExpressionFactory.HeapConstructor("Keeper")), Block.CreateStatement( VariableDeclaration.CreateStatement("s", null, ExpressionFactory.StackConstructor("Keeper")), Assignment.CreateStatement(NameReference.Create("i"), heap_get_ref), Assignment.CreateStatement(NameReference.Create("i"), stack_get_ref) ), ExpressionFactory.Readout("i") ))); resolver = NameResolver.Create(env); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EscapingReference, heap_get_ref)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EscapingReference, stack_get_ref)); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); } 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); }
public IErrorReporter OutgoingConversion() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; var type_foo_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Foo")) .With(FunctionBuilder.Create( NameFactory.ConvertFunctionName, null, ExpressionReadMode.ReadRequired, NameReference.Create("Bar"), Block.CreateStatement(new IExpression[] { Return.Create(Undef.Create()) })) .SetModifier(EntityModifier.Implicit)) // added second conversion to check if compiler correctly disambiguate the call .With(FunctionBuilder.Create( NameFactory.ConvertFunctionName, null, ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new IExpression[] { Return.Create(Undef.Create()) })) .SetModifier(EntityModifier.Implicit))); var type_bar_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Bar"))); root_ns.AddBuilder(FunctionBuilder.Create( "wrapper", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { VariableDeclaration.CreateStatement("f", NameReference.Create("Foo"), initValue: Undef.Create()), VariableDeclaration.CreateStatement("b", NameReference.Create("Bar"), initValue: NameReference.Create("f")), ExpressionFactory.Readout("b") }))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IEnumerable <VariableDeclaration> Build(TypeBuilder typeBuilder) { if (build == null) { build = new List <VariableDeclaration>(); NameReference typename = typeBuilder.CreateTypeNameReference(); foreach (string s in cases) { build.Add(VariableDeclaration.CreateStatement(s, typename, // we cannot set the initial value here because we don't know how many cases are in parent enums Undef.Create(), EntityModifier.Enum | EntityModifier.Static | EntityModifier.Public)); } } return(build); }
internal IEntity HijackEscapingReference(VariableDeclaration localVariable) { // we replace here the escaping local variable (or rather variable that breaks lambda barrier) // with field of the type which soon will be created if (localVariable == null) { throw new Exception("Internal error"); } VariableDeclaration field; if (!this.escapingVariableToFieldMapping.TryGetValue(localVariable, out field)) { field = VariableDeclaration.CreateStatement(localVariable.Name.Name, localVariable.Evaluation.Components.PureNameOf, Undef.Create()); this.escapingVariableToFieldMapping.Add(localVariable, field); } return(field); }
public IErrorReporter ErrorPersistentReferenceType() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true, GlobalVariables = true, RelaxedMode = true }.SetMutability(mutability)); var root_ns = env.Root; var decl1 = VariableDeclaration.CreateStatement("bar", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()), initValue: Undef.Create(), modifier: EntityModifier.Public); root_ns.AddNode(decl1); var decl2 = VariableDeclaration.CreateStatement("bar", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()), initValue: Undef.Create(), modifier: EntityModifier.Static); var func_def_void = root_ns.AddBuilder(FunctionBuilder.Create( "notimportant", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { decl2, ExpressionFactory.Readout("bar") }))); resolver = NameResolver.Create(env); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.PersistentReferenceVariable, decl1)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.PersistentReferenceVariable, decl2)); } return(resolver); }
public IErrorReporter ErrorMutabilityNotIgnoredOnNonValueCopy() { NameResolver resolver = null; foreach (var mutability in Options.StrictMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true, }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Mutant") .With(VariableDeclaration.CreateStatement("x", NameFactory.PointerNameReference(NameFactory.IntNameReference()), Undef.Create(), EntityModifier.Public)) .SetModifier(EntityModifier.Mutable)); // we cannot make such assignment, because type is not pure value, // so its field (pointer) can be shared and mutated this way VariableDeclaration decl = VariableDeclaration.CreateStatement("x", NameReference.Create(TypeMutability.ForceMutable, "Mutant"), ExpressionFactory.StackConstructor(NameReference.Create(TypeMutability.ForceConst, "Mutant"))); root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { decl, ExpressionFactory.Readout("x"), }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, decl.InitValue)); } return(resolver); }
public IErrorReporter ForcingConstIndirectly() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true, DebugThrowOnError = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Stone")); root_ns.AddBuilder(TypeBuilder.Create("Mutator", "M") .SetModifier(EntityModifier.Mutable)); root_ns.AddBuilder(TypeBuilder.Create("Mangler") .SetModifier(EntityModifier.Mutable) .With(VariableDeclaration.CreateStatement("f", NameFactory.PointerNameReference(NameReference.Create("Mutator", NameReference.Create("Stone"))), Undef.Create(), EntityModifier.Public)) ); root_ns.AddBuilder(TypeBuilder.Create("Keeper") .With(VariableDeclaration.CreateStatement("f", NameFactory.PointerNameReference(NameReference.Create(TypeMutability.ForceConst, "Mangler")), Undef.Create(), EntityModifier.Public)) ); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } 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 ProperGenericMethodOverrideWithGenericOutput() { 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(NameDefinition.Create("IMyInterface", TemplateParametersBuffer.Create().Add("TI").Values)) .With(FunctionBuilder.CreateDeclaration( "bar", ExpressionReadMode.OptionalUse, NameFactory.ReferenceNameReference(NameReference.Create("TI"))))); TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("MyImpl", TemplateParametersBuffer.Create().Add("MV").Values)) .With(FunctionBuilder.Create( "bar", ExpressionReadMode.OptionalUse, NameFactory.ReferenceNameReference(NameReference.Create("MV")), Block.CreateStatement(new[] { Return.Create(Undef.Create()) })) .SetModifier(EntityModifier.Override)) .Parents(NameReference.Create("IMyInterface", NameReference.Create("MV")))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter TransitiveMutabilityTypeDefinition() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; VariableDeclaration decl = VariableDeclaration.CreateStatement("m", NameReference.Create("T"), Undef.Create(), modifier: EntityModifier.Public); // we can declare type Point as non-mutable, because it will be mutable or not depending on T TypeDefinition point_type = root_ns.AddBuilder(TypeBuilder.Create("Point", "T") .With(decl)); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorAssigningSimpleRValues() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; var func_def = root_ns.AddBuilder(FunctionBuilder.Create( "getter", null, ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new[] { Return.Create(Int64Literal.Create("5")) }))); FunctionCall call = FunctionCall.Create(NameReference.Create("getter")); NameReference func_ref = NameReference.Create("getter"); root_ns.AddNode(Block.CreateStatement(new IExpression[] { VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), Undef.Create()), // errors: assigning to r-value Assignment.CreateStatement(call, NameReference.Create("i")), Assignment.CreateStatement(func_ref, Undef.Create()) })); resolver = NameResolver.Create(env); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssigningRValue, call)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AssigningRValue, func_ref)); } return(resolver); }
public IErrorReporter ErrorStaticMemberReference() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { StaticMemberOnlyThroughTypeName = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Foo") .With(VariableDeclaration.CreateStatement("field", NameFactory.RealNameReference(), null, EntityModifier.Static | EntityModifier.Public))); NameReference field_ref = NameReference.Create("f", "field"); root_ns.AddBuilder(FunctionBuilder.Create("foo", ExpressionReadMode.OptionalUse, NameFactory.RealNameReference(), Block.CreateStatement(new IExpression[] { VariableDeclaration.CreateStatement("f", NameReference.Create("Foo"), Undef.Create()), Return.Create(field_ref) }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.StaticMemberAccessInInstanceContext, field_ref)); } return(resolver); }
public IErrorReporter ErrorUnusedVariableWithinUsedExpression() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; VariableDeclaration decl = VariableDeclaration.CreateExpression("result", NameFactory.Int64NameReference(), initValue: Undef.Create()); root_ns.AddBuilder(FunctionBuilder.Create("anything", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement( // the declaration-expression is used, but the variable itself is not // thus we report it as unused (in such code user should pass the init-value itself w/o creating variable) ExpressionFactory.Readout(decl) ))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.BindableNotUsed, decl.Name)); } return(resolver); }
public IErrorReporter ErrorInvalidVariable() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; VariableDeclaration decl = VariableDeclaration.CreateStatement("x", null, Int64Literal.Create("3"), modifier: EntityModifier.Public); root_ns.AddNode(decl); VariableDeclaration empty_decl1 = VariableDeclaration.CreateStatement("empty1", null, Undef.Create()); VariableDeclaration empty_decl2 = VariableDeclaration.CreateStatement("empty2", null, null); root_ns.AddBuilder(FunctionBuilder.Create("testing", NameFactory.UnitNameReference(), Block.CreateStatement( empty_decl1, empty_decl2, ExpressionFactory.Readout("empty1"), ExpressionFactory.Readout("empty2") ))); resolver = NameResolver.Create(env); Assert.AreEqual(4, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.GlobalVariable, decl)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MissingTypeName, decl)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MissingTypeName, empty_decl1)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MissingTypeAndValue, empty_decl2)); } return(resolver); }
public IErrorReporter TypeInference() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true, DebugThrowOnError = true }.SetMutability(mutability)); var root_ns = env.Root; var var_x = VariableDeclaration.CreateStatement("x", NameFactory.RealNameReference(), Undef.Create()); var var_y = VariableDeclaration.CreateStatement("y", null, NameReference.Create("x")); var func_def_void = root_ns.AddBuilder(FunctionBuilder.Create( "notimportant", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { var_x, var_y, ExpressionFactory.Readout("y") }))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); Assert.IsTrue(env.Real64Type.InstanceOf.HasSameCore(var_y.Evaluation.Components)); } return(resolver); }
public IErrorReporter AssignmentTypeChecking() { 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; var system_ns = env.SystemNamespace; root_ns.AddNode(VariableDeclaration.CreateStatement("x", NameFactory.RealNameReference(), Undef.Create())); root_ns.AddNode(VariableDeclaration.CreateStatement("y", NameFactory.RealNameReference(), NameReference.Create("x"), modifier: EntityModifier.Public)); var x_ref = NameReference.Create("x"); root_ns.AddNode(VariableDeclaration.CreateStatement("z", NameFactory.Int64NameReference(), x_ref, modifier: EntityModifier.Public)); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, x_ref)); } return(resolver); }
public IErrorReporter VariableBinding() { 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 decl_1 = VariableDeclaration.CreateStatement("x", NameFactory.RealNameReference(), Undef.Create(), modifier: EntityModifier.Public); root_ns.AddNode(decl_1); var var_1_ref = NameReference.Create("x"); var decl_2 = root_ns.AddNode(VariableDeclaration.CreateStatement("y", NameFactory.RealNameReference(), var_1_ref, modifier: EntityModifier.Public)); resolver = NameResolver.Create(env); Assert.AreEqual(1, decl_1.TypeName.Binding().Matches.Count); Assert.AreEqual(env.Real64Type, decl_1.TypeName.Binding().Match.Instance.Target); Assert.AreEqual(1, var_1_ref.Binding.Matches.Count); Assert.AreEqual(decl_1, var_1_ref.Binding.Match.Instance.Target); } return(resolver); }
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 IInterpreter GenericTypeAliasing() { var interpreter = new Interpreter.Interpreter(); foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DebugThrowOnError = true }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Point", "V", VarianceMode.None)) .With(Alias.Create("VType", NameReference.Create("V"), EntityModifier.Public))); VariableDeclaration decl = VariableDeclaration.CreateStatement("x", NameReference.Create("p", "VType"), Undef.Create(), env.Options.ReassignableModifier()); root_ns.AddBuilder(FunctionBuilder.Create("main", NameFactory.Nat8NameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("p", null, ExpressionFactory.StackConstructor(NameReference.Create("Point", NameFactory.Nat8NameReference()))), decl, Assignment.CreateStatement(NameReference.Create("x"), Nat8Literal.Create("5")), Return.Create(NameReference.Create("x")) ))); ExecValue result = interpreter.TestRun(env); Assert.AreEqual((byte)5, result.RetValue.PlainValue); } return(interpreter); }
public IErrorReporter InternalIndirectTranslationTables() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { MiniEnvironment = true, DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; const string proxy_typename = "Proxy"; const string proxy_elemtype = "X"; FunctionDefinition get_func = FunctionBuilder.Create("getMe", ExpressionReadMode.OptionalUse, NameReference.Create(proxy_elemtype), Block.CreateStatement(Return.Create(Undef.Create()))); TypeDefinition proxy = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(proxy_typename, TemplateParametersBuffer.Create(proxy_elemtype).Values)) .With(get_func)); const string parent_typename = "Oldman"; const string parent_elemtype = "PT"; FunctionDefinition access_func = FunctionBuilder.Create("provide", ExpressionReadMode.OptionalUse, NameFactory.ReferenceNameReference(NameReference.Create(proxy_typename, NameReference.Create(parent_elemtype))), Block.CreateStatement(Return.Create(Undef.Create()))); TypeDefinition parent = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(parent_typename, TemplateParametersBuffer.Create(parent_elemtype).Values)) .SetModifier(EntityModifier.Base) .With(access_func) ); const string child_typename = "Kid"; const string child_elemtype = "CT"; FunctionCall call = FunctionCall.Create(NameReference.Create("i", "getMe")); // with buggy template translation table we would have here a type mismatch error // if this error happens check first if prefix of the call is evaluated correctly VariableDeclaration assignment = VariableDeclaration.CreateStatement("e", NameReference.Create(child_elemtype), call); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(child_typename, TemplateParametersBuffer.Create(child_elemtype).Values)) .Parents(NameReference.Create(parent_typename, NameReference.Create(child_elemtype))) .With(FunctionBuilder.Create("process", ExpressionReadMode.CannotBeRead, NameFactory.UnitNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("i", NameFactory.ReferenceNameReference(NameReference.Create(proxy_typename, NameReference.Create(child_elemtype))), FunctionCall.Create(NameReference.CreateThised("provide"))), ExpressionFactory.Readout("i"), assignment, ExpressionFactory.Readout("e") )))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorInOutVarianceFields() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true } .SetMutability(mutability)); var root_ns = env.Root; NameReference field_a_typename = NameReference.Create("TA"); NameReference field_b_typename = NameReference.Create("TB"); root_ns.AddBuilder(TypeBuilder.Create( NameDefinition.Create(NameFactory.TupleTypeName, TemplateParametersBuffer.Create().Add("TA", VarianceMode.In).Add("TB", VarianceMode.Out).Values)) .SetModifier(EntityModifier.Mutable) .With(VariableDeclaration.CreateStatement("fa", field_a_typename, Undef.Create(), env.Options.ReassignableModifier() | EntityModifier.Public)) .With(VariableDeclaration.CreateStatement("fb", field_b_typename, Undef.Create(), env.Options.ReassignableModifier() | EntityModifier.Public))); resolver = NameResolver.Create(env); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.VarianceForbiddenPosition, field_a_typename)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.VarianceForbiddenPosition, field_b_typename)); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorInOutVarianceProperties() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true } .SetMutability(mutability)); var root_ns = env.Root; NameReference prop_a_typename = NameReference.Create("TA"); NameReference prop_b_typename = NameReference.Create("TB"); root_ns.AddBuilder(TypeBuilder.Create( NameDefinition.Create(NameFactory.TupleTypeName, TemplateParametersBuffer.Create().Add("TA", VarianceMode.In).Add("TB", VarianceMode.Out).Values)) .SetModifier(EntityModifier.Mutable) .With(ExpressionFactory.BasicConstructor(new[] { "adata", "bdata" }, new[] { NameReference.Create("TA"), NameReference.Create("TB") })) .With(PropertyBuilder.CreateAutoFull(env.Options, "adata", prop_a_typename, Undef.Create())) .With(PropertyBuilder.CreateAutoFull(env.Options, "bdata", prop_b_typename, Undef.Create()))); resolver = NameResolver.Create(env); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.VarianceForbiddenPosition, prop_a_typename)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.VarianceForbiddenPosition, prop_b_typename)); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter InternalDirectTranslationTables() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { MiniEnvironment = true }.SetMutability(mutability)); var root_ns = env.Root; const string parent_typename = "Oldman"; const string parent_elemtype = "PT"; FunctionDefinition base_func = FunctionBuilder.CreateDeclaration("getMe", ExpressionReadMode.CannotBeRead, NameFactory.ReferenceNameReference(parent_elemtype)); TypeDefinition parent = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(parent_typename, TemplateParametersBuffer.Create(parent_elemtype).Values)) .SetModifier(EntityModifier.Abstract) .With(base_func)); const string child_typename = "Kid"; const string child_elemtype = "CT"; FunctionDefinition deriv_func = FunctionBuilder.Create("getMe", ExpressionReadMode.CannotBeRead, NameFactory.ReferenceNameReference(child_elemtype), Block.CreateStatement(Return.Create(Undef.Create()))) .SetModifier(EntityModifier.Override); TypeDefinition child = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(child_typename, TemplateParametersBuffer.Create(child_elemtype).Values)) .Parents(NameReference.Create(parent_typename, NameReference.Create(child_elemtype))) .With(deriv_func)); resolver = NameResolver.Create(env); // testing here template translation EntityInstance child_ancestor = child.Inheritance.OrderedAncestorsWithoutObject.Single(); IEntityInstance translated = base_func.ResultTypeName.Evaluation.Components.TranslateThrough(child_ancestor); // we have single function overriden, so it is easy to debug and spot if something goes wrong bool result = FunctionDefinitionExtension.IsDerivedOf(resolver.Context, deriv_func, base_func, child_ancestor); Assert.IsTrue(result); } return(resolver); }