public IErrorReporter ErrorEnumCrossInheritance()
{
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("Whatever")
.SetModifier(EntityModifier.Base));
TypeDefinition from_reg = root_ns.AddBuilder(TypeBuilder.CreateEnum("Sizing")
.Parents("Whatever")
.SetModifier(EntityModifier.Base)
.With(EnumCaseBuilder.Create("small", "big")));
TypeDefinition from_enum = root_ns.AddBuilder(TypeBuilder.Create("Another")
.Parents("Sizing")
.SetModifier(EntityModifier.Base));
resolver = NameResolver.Create(env);
Assert.AreEqual(2, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EnumCrossInheritance, from_enum));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EnumCrossInheritance, from_reg));
}
return(resolver);
}
public IErrorReporter ConflictingTypeNameWithAlias()
{
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("Whatever")
.SetModifier(EntityModifier.Base));
TypeDefinition from_reg = root_ns.AddBuilder(TypeBuilder.CreateEnum(NameFactory.SizeTypeName)
.Parents("Whatever")
.SetModifier(EntityModifier.Base)
.With(EnumCaseBuilder.Create("small", "big")));
TypeDefinition from_enum = root_ns.AddBuilder(TypeBuilder.Create("Another")
.Parents(NameFactory.SizeTypeName)
.SetModifier(EntityModifier.Base));
resolver = NameResolver.Create(env);
}
return(resolver);
}
public IInterpreter InheritingEnums()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateEnum("Weekend")
.With(EnumCaseBuilder.Create("Sat", "Sun"))
.SetModifier(EntityModifier.Base));
root_ns.AddBuilder(TypeBuilder.CreateEnum("First")
.With(EnumCaseBuilder.Create("Mon"))
.Parents("Weekend"));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.NatNameReference(),
Block.CreateStatement(new IExpression[] {
// let a Weekend = First.Sat
VariableDeclaration.CreateStatement("a", NameReference.Create("Weekend"),
// please note we only refer to "Sat" through "First", the type is still "Weekend"
NameReference.Create("First", "Sat")),
// var b First = Weekend.Sun
VariableDeclaration.CreateStatement("b", NameReference.Create("First"), NameReference.Create("Weekend", "Sun"),
env.Options.ReassignableModifier()),
// b = First.Mon
Assignment.CreateStatement(NameReference.Create("b"), NameReference.Create("First", "Mon")),
// let x = a to Nat; // 0
VariableDeclaration.CreateStatement("x", null, FunctionCall.ConvCall(NameReference.Create("a"),
NameFactory.NatNameReference())),
// let y = b to Nat; // 2
VariableDeclaration.CreateStatement("y", null, FunctionCall.ConvCall(NameReference.Create("b"),
NameFactory.NatNameReference())),
// return x + y
Return.Create(ExpressionFactory.Add(NameReference.Create("x"), NameReference.Create("y")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2UL, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ErrorInvalidDirectionPassingEnums()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateEnum("Weekend")
.With(EnumCaseBuilder.Create("Sat", "Sun"))
.SetModifier(EntityModifier.Base));
root_ns.AddBuilder(TypeBuilder.CreateEnum("First")
.With(EnumCaseBuilder.Create("Mon"))
.Parents("Weekend"));
IExpression init_value = ExpressionFactory.HeapConstructor("First", NameReference.Create("First", "Mon"));
root_ns.AddBuilder(FunctionBuilder.Create(
"some",
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("a", NameFactory.PointerNameReference(NameReference.Create("Weekend")),
init_value),
ExpressionFactory.Readout("a")
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, init_value));
}
return(resolver);
}
