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);
}
