public IErrorReporter ErrorSlicingOnDereference() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { AllowDereference = true }.SetMutability(mutability)); var root_ns = env.Root; Int64Literal rhs_value = IntLiteral.Create("80"); root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("p", NameFactory.PointerNameReference(NameFactory.IObjectNameReference(TypeMutability.Reassignable)), Undef.Create()), // only with same type we have guarantee we won't use dereference as slicing tool, consider // x *Object ; (*x) = big_type_instance Assignment.CreateStatement(Dereference.Create(NameReference.Create("p")), rhs_value) ))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, rhs_value)); } return(resolver); }
public IErrorReporter ErrorSettingPropertyReferenceField() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { AllowReferenceFields = true }.SetMutability(mutability)); var root_ns = env.Root; // this is incorrect we use &Int in setter (OK) but we store this reference in a field too (bad) Property property = PropertyBuilder.Create(env.Options, "meow", () => NameFactory.ReferenceNameReference(NameFactory.IntNameReference())) .WithAutoField(Undef.Create(), EntityModifier.Reassignable) .WithAutoSetter(); root_ns.AddBuilder(TypeBuilder.Create("whatever") .SetModifier(EntityModifier.Mutable) .With(property)); resolver = NameResolver.Create(env); var setter_assignment = property.Setter.UserBody.Instructions.Single().Cast <Assignment>(); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EscapingReference, setter_assignment.RhsValue)); } return(resolver); }
public IErrorReporter ForcingConstDirectly() { 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("Keeper") .With(VariableDeclaration.CreateStatement("f", NameFactory.PointerNameReference(NameReference.Create(TypeMutability.ForceConst, "Mutator", NameReference.Create("Stone"))), Undef.Create(), EntityModifier.Public)) ); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorImmutableTypeDefinition() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; root_ns.AddBuilder(TypeBuilder.Create("Bar") .SetModifier(EntityModifier.Mutable)); VariableDeclaration decl1 = VariableDeclaration.CreateStatement("r", NameFactory.Int64NameReference(), null, env.Options.ReassignableModifier() | EntityModifier.Public); VariableDeclaration decl2 = VariableDeclaration.CreateStatement("m", NameReference.Create("Bar"), Undef.Create(), modifier: EntityModifier.Public); TypeDefinition point_type = root_ns.AddBuilder(TypeBuilder.Create("Point") .With(decl1) .With(decl2)); resolver = NameResolver.Create(env); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MutableFieldInImmutableType, decl1)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MutableFieldInImmutableType, decl2)); } return(resolver); }
public IErrorReporter PassingPointers() { 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; var decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.PointerNameReference(NameFactory.RealNameReference()), initValue: Undef.Create(), modifier: EntityModifier.Public); var decl_dst = VariableDeclaration.CreateStatement("bar", NameFactory.PointerNameReference(NameFactory.IObjectNameReference()), initValue: NameReference.Create("foo"), 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 ErrorReassignableReferenceField() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { AllowReferenceFields = true, DiscardingAnyExpressionDuringTests = true } .SetMutability(mutability)); var root_ns = env.Root; VariableDeclaration decl = VariableDeclaration.CreateStatement("f", NameFactory.ReferenceNameReference(NameFactory.IntNameReference()), Undef.Create(), EntityModifier.Reassignable | EntityModifier.Public); root_ns.AddBuilder(TypeBuilder.Create("X") .SetModifier(EntityModifier.Mutable) .With(decl)); resolver = NameResolver.Create(env); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ReferenceFieldCannotBeReassignable, decl)); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorTestingMismatchedTypes() { 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.Int64NameReference())); var decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.PointerNameReference(NameFactory.RealNameReference()), 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(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, is_type)); } return(resolver); }
public IErrorReporter ImplicitPointerReferenceConversion() { 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 decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.PointerNameReference(NameFactory.Int64NameReference()), initValue: Undef.Create()); var decl_dst = VariableDeclaration.CreateStatement("bar", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()), initValue: NameReference.Create("foo")); var func_def_void = root_ns.AddBuilder(FunctionBuilder.Create( "notimportant", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { decl_src, decl_dst, ExpressionFactory.Readout("bar") }))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter CircularPointerNesting() { 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(NameDefinition.Create("Shape")) .With(FunctionBuilder.Create("reader", NameFactory.UnitNameReference(), Block.CreateStatement(ExpressionFactory.Readout(NameReference.CreateThised("s"))))) .With(VariableDeclaration.CreateStatement("s", NameFactory.PointerNameReference(NameReference.Create("Form")), Undef.Create(), EntityModifier.Private))); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Form")) .With(FunctionBuilder.Create("reader", NameFactory.UnitNameReference(), Block.CreateStatement(ExpressionFactory.Readout(NameReference.CreateThised("f"))))) .With(VariableDeclaration.CreateStatement("f", NameFactory.PointerNameReference(NameReference.Create("Shape")), Undef.Create(), EntityModifier.Private))); 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 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 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 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); }
/*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 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 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 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); }