private IErrorReporter errorDuckTypingValues(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") .SetModifier(env.Options.InterfaceDuckTyping ? EntityModifier.Interface : EntityModifier.Protocol)); root_ns.AddBuilder(TypeBuilder.Create("X")); IExpression init_value = ExpressionFactory.StackConstructor(NameReference.Create("X")); // even with duck typing we cannot make the assigment because slicing is forbidden in all cases VariableDeclaration decl = VariableDeclaration.CreateStatement("i", NameReference.Create("IX"), init_value); var main_func = root_ns.AddBuilder(FunctionBuilder.Create( "main", ExpressionReadMode.OptionalUse, NameFactory.Int64NameReference(), Block.CreateStatement(new IExpression[] { decl, ExpressionFactory.Readout("i"), Return.Create(Int64Literal.Create("2")) }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, init_value)); } 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 ErrorNoDefaultConstructor() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; var bar_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Bar")) .With(FunctionDefinition.CreateInitConstructor(EntityModifier.None, new[] { FunctionParameter.Create("a", NameFactory.Int64NameReference(), Variadic.None, null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead) }, Block.CreateStatement()))); VariableDeclaration field_decl = VariableDeclaration.CreateStatement("x", NameReference.Create("Bar"), null, EntityModifier.Public); var type_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Point")) .With(field_decl)); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NoDefaultConstructor, field_decl)); } return(resolver); }
public IErrorReporter ErrorReassigningFixedVariable() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; IExpression assignment = Assignment.CreateStatement(NameReference.Create("x"), Int64Literal.Create("5")); root_ns.AddBuilder(FunctionBuilder.Create( "notimportant", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { VariableDeclaration.CreateStatement("x", null, Int64Literal.Create("3")), assignment, ExpressionFactory.Readout("x") }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotReassignReadOnlyVariable, assignment)); } 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 ErrorTraitDefinition() { 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("Bar") .SetModifier(EntityModifier.Base)); TypeDefinition non_generic_trait = root_ns.AddBuilder(TypeBuilder.Create("Bar") .SetModifier(EntityModifier.Trait)); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Foo", "T", VarianceMode.None))); TypeDefinition unconstrained_trait = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Foo", "T", VarianceMode.None)) .SetModifier(EntityModifier.Trait)); TypeDefinition missing_host = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("MissMe", "Y", VarianceMode.None)) .SetModifier(EntityModifier.Trait) .Constraints(ConstraintBuilder.Create("Y") .SetModifier(EntityModifier.Const))); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Almost", "T", VarianceMode.None))); FunctionDefinition trait_constructor = FunctionBuilder.CreateInitConstructor(Block.CreateStatement()); VariableDeclaration trait_field = VariableDeclaration.CreateStatement("f", NameFactory.Int64NameReference(), Int64Literal.Create("5"), EntityModifier.Public); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Almost", "T", VarianceMode.None)) .SetModifier(EntityModifier.Trait) .With(trait_constructor) .With(trait_field) .Constraints(ConstraintBuilder.Create("T") .SetModifier(EntityModifier.Const))); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Inheriting", "T", VarianceMode.None))); NameReference parent_impl = NameReference.Create("Bar"); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Inheriting", "T", VarianceMode.None)) .Parents(parent_impl) .SetModifier(EntityModifier.Trait) .Constraints(ConstraintBuilder.Create("T") .SetModifier(EntityModifier.Const))); resolver = NameResolver.Create(env); Assert.AreEqual(6, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NonGenericTrait, non_generic_trait)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.UnconstrainedTrait, unconstrained_trait)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MissingHostTypeForTrait, missing_host)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TraitConstructor, trait_constructor)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TraitInheritingTypeImplementation, parent_impl)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.FieldInNonImplementationType, trait_field)); } return(resolver); }
public static IExpression CreateForEach(string varName, INameReference varTypeName, IExpression iterable, IEnumerable <IExpression> body) { string iter_name = AutoName.Instance.CreateNew("iter"); VariableDeclaration iter_decl = VariableDeclaration.CreateStatement(iter_name, null, FunctionCall.Create(NameReference.Create(iterable, NameFactory.IterableGetIterator))); IExpression condition; if (varName == NameFactory.Sink) { condition = ExpressionFactory.OptionalAssignment(NameFactory.SinkReference(), FunctionCall.Create(NameReference.Create(iter_name, NameFactory.IteratorNext))); } else { string elem_name = AutoName.Instance.CreateNew("elem"); body = VariableDeclaration.CreateStatement(varName, varTypeName, NameReference.Create(elem_name)) .Concat(body); condition = ExpressionFactory.OptionalDeclaration(elem_name, varTypeName, FunctionCall.Create(NameReference.Create(iter_name, NameFactory.IteratorNext))); } return(create(null, new[] { iter_decl }, preCondition: condition, body: body, postStep: null, postCondition: null)); }
public IErrorReporter ErrorDiscardingNonFunctionCall() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; IExpression discard = ExpressionFactory.Readout("c"); root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { VariableDeclaration.CreateStatement("c", null, Int64Literal.Create("3")), discard, }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.DiscardingNonFunctionCall, discard)); } return(resolver); }
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 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 ErrorReassignableGlobalVariables() { 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; root_ns.AddBuilder(TypeBuilder.Create("Bar") .SetModifier(EntityModifier.Mutable)); VariableDeclaration decl1 = VariableDeclaration.CreateStatement("r", NameFactory.Int64NameReference(), null, env.Options.ReassignableModifier() | EntityModifier.Public); root_ns.AddNode(decl1); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.GlobalMutableVariable, decl1)); } return(resolver); }
public IErrorReporter MutabilityIgnoredOnValueCopy() { 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("Mutant") .With(VariableDeclaration.CreateStatement("x", NameFactory.IntNameReference(), Undef.Create(), EntityModifier.Public)) .SetModifier(EntityModifier.Mutable)); root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { VariableDeclaration.CreateStatement("x", NameReference.Create(TypeMutability.ForceMutable, "Mutant"), ExpressionFactory.StackConstructor(NameReference.Create(TypeMutability.ForceConst, "Mutant"))), ExpressionFactory.Readout("x"), }))); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } return(resolver); }
public IErrorReporter ErrorImmutableMethodAlteringData() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Language.Environment.Create(new Options() { }.SetMutability(mutability)); var root_ns = env.Root; IExpression assignment = Assignment.CreateStatement(NameReference.CreateThised("f"), Int64Literal.Create("5")); root_ns.AddBuilder(TypeBuilder.Create("Elka") .SetModifier(EntityModifier.Mutable) .With(VariableDeclaration.CreateStatement("f", NameFactory.Int64NameReference(), null, EntityModifier.Public | env.Options.ReassignableModifier())) .With(FunctionBuilder.Create("mutator", NameFactory.UnitNameReference(), Block.CreateStatement( assignment )))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AlteringCurrentInImmutableMethod, assignment)); } 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 ErrorCallingHeapMethodOnValue() { 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("Hi") .With(FunctionBuilder.Create("give", NameFactory.UnitNameReference(), Block.CreateStatement()) .SetModifier(EntityModifier.HeapOnly))); FunctionCall call = FunctionCall.Create(NameReference.Create("v", "give")); root_ns.AddBuilder(FunctionBuilder.Create( "notimportant", ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement( VariableDeclaration.CreateStatement("v", null, ExpressionFactory.StackConstructor("Hi")), call ))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CallingHeapFunctionWithValue, call)); } return(resolver); }
public IErrorReporter ErrorAddressingRValue() { NameResolver resolver = null; foreach (var mutability in Options.AllMutabilityModes) { var env = Environment.Create(new Options() { DiscardingAnyExpressionDuringTests = true }.SetMutability(mutability)); var root_ns = env.Root; Int64Literal int_literal = Int64Literal.Create("1"); var func_def = root_ns.AddBuilder(FunctionBuilder.Create( "foo", null, ExpressionReadMode.OptionalUse, NameFactory.UnitNameReference(), Block.CreateStatement(new[] { VariableDeclaration.CreateStatement("x", null, AddressOf.CreatePointer(int_literal)), VariableDeclaration.CreateStatement("y", null, AddressOf.CreateReference(Int64Literal.Create("2"))), ExpressionFactory.Readout("x"), ExpressionFactory.Readout("y"), }))); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.AddressingRValue, int_literal)); } 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 ReadingIfAsExpression() { 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 if_ctrl = IfBranch.CreateIf(BoolLiteral.CreateTrue(), new IExpression[] { Int64Literal.Create("5") }, IfBranch.CreateElse(new[] { Int64Literal.Create("7") })); root_ns.AddNode(VariableDeclaration.CreateStatement("x", NameFactory.Int64NameReference(), if_ctrl, EntityModifier.Public)); resolver = NameResolver.Create(env); Assert.AreEqual(0, resolver.ErrorManager.Errors.Count); } 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 ErrorUsingNonValue() { 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; NameReference non_value = NameFactory.Int64NameReference(); root_ns.AddNode(VariableDeclaration.CreateStatement("x", NameFactory.Int64NameReference(), initValue: non_value, modifier: EntityModifier.Public)); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NoValueExpression, non_value)); } return(resolver); }
public IInterpreter InitializingWithGetter() { 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("Point") .With(PropertyBuilder.CreateAutoGetter(env.Options, "x", NameFactory.Nat8NameReference())) .With(FunctionBuilder.CreateInitConstructor(Block.CreateStatement( Assignment.CreateStatement(NameReference.CreateThised("x"), Nat8Literal.Create("5")) )))); root_ns.AddBuilder(FunctionBuilder.Create( "main", ExpressionReadMode.OptionalUse, NameFactory.Nat8NameReference(), Block.CreateStatement(new IExpression[] { VariableDeclaration.CreateStatement("p", null, ExpressionFactory.StackConstructor(NameReference.Create("Point"))), Return.Create(NameReference.Create(NameReference.Create("p"), "x")) }))); ExecValue result = interpreter.TestRun(env); Assert.AreEqual((byte)5, result.RetValue.PlainValue); } return(interpreter); }
public IErrorReporter ErrorIgnoringFunctionResult() { 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 func_def = root_ns.AddBuilder(FunctionBuilder.Create( "foo", ExpressionReadMode.ReadRequired, NameFactory.RealNameReference(), Block.CreateStatement(new[] { Return.Create(RealLiteral.Create("3.3")) })) .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"))); root_ns.AddNode(Block.CreateStatement(new[] { call })); resolver = NameResolver.Create(env); Assert.AreEqual(1, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ExpressionValueNotUsed, 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 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 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 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 ErrorCircularValueNesting() { 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; VariableDeclaration decl1 = VariableDeclaration.CreateStatement("s", NameReference.Create("Form"), null, EntityModifier.Private); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Shape")) .With(FunctionBuilder.Create("reader", NameFactory.UnitNameReference(), Block.CreateStatement(ExpressionFactory.Readout(NameReference.CreateThised("s"))))) .With(decl1)); VariableDeclaration decl2 = VariableDeclaration.CreateStatement("f", NameReference.Create("Shape"), null, EntityModifier.Private); root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Form")) .With(FunctionBuilder.Create("reader", NameFactory.UnitNameReference(), Block.CreateStatement(ExpressionFactory.Readout(NameReference.CreateThised("f"))))) .With(decl2)); resolver = NameResolver.Create(env); Assert.AreEqual(2, resolver.ErrorManager.Errors.Count); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NestedValueOfItself, decl1)); Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NestedValueOfItself, decl2)); } 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 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 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); }