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 IInterpreter TypeUnion()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowProtocols = true,
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.Create("GetPos")
.With(FunctionBuilder.Create("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("3"))
}))));
root_ns.AddBuilder(TypeBuilder.Create("GetNeg")
.With(FunctionBuilder.Create("getSome", ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("-1"))
}))));
NameReferenceUnion union = NameReferenceUnion.Create(NameFactory.PointerNameReference(NameReference.Create("GetNeg")),
NameFactory.PointerNameReference(NameReference.Create("GetPos")));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("a", union, Undef.Create(), env.Options.ReassignableModifier()),
VariableDeclaration.CreateStatement("b", union, Undef.Create(), env.Options.ReassignableModifier()),
Assignment.CreateStatement(NameReference.Create("a"), ExpressionFactory.HeapConstructor("GetPos")),
Assignment.CreateStatement(NameReference.Create("b"), ExpressionFactory.HeapConstructor("GetNeg")),
VariableDeclaration.CreateStatement("x", null, FunctionCall.Create(NameReference.Create("a", "getSome"))),
VariableDeclaration.CreateStatement("y", null, FunctionCall.Create(NameReference.Create("b", "getSome"))),
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 UnionMatching()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
var system_ns = env.SystemNamespace;
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Separate")));
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("ABC")));
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Deriv"))
.Parents(NameReference.Create("ABC")));
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Deriz"))
.Parents(NameReference.Create("Deriv")));
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("qwerty"))
.Parents(NameReference.Create("ABC")));
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("sink"))
.Parents(NameReference.Create("qwerty"), NameReference.Create("Separate")));
var separate_deriv_union = root_ns.AddNode(NameReferenceUnion.Create(NameReference.Create("Separate"), NameReference.Create("Deriv")));
var separate_deriz_union = root_ns.AddNode(NameReferenceUnion.Create(NameReference.Create("Separate"), NameReference.Create("Deriz")));
var separate_abc_union = root_ns.AddNode(NameReferenceUnion.Create(NameReference.Create("Separate"), NameReference.Create("ABC")));
var sink_union = root_ns.AddNode(NameReferenceUnion.Create(NameReference.Create("sink")));
var sink_deriv_union = root_ns.AddNode(NameReferenceUnion.Create(NameReference.Create("sink"), NameReference.Create("Deriv")));
resolver = NameResolver.Create(env);
Assert.AreEqual(TypeMatch.Substitute, separate_deriz_union.Evaluation.Components.MatchesTarget(resolver.Context,
separate_deriv_union.Evaluation.Components, TypeMatching.Create(env.Options.InterfaceDuckTyping, allowSlicing: true)));
Assert.AreEqual(TypeMatch.Substitute, sink_union.Evaluation.Components.MatchesTarget(resolver.Context,
separate_abc_union.Evaluation.Components, TypeMatching.Create(env.Options.InterfaceDuckTyping, allowSlicing: true)));
TypeMatch match = sink_deriv_union.Evaluation.Components.MatchesTarget(resolver.Context,
separate_deriz_union.Evaluation.Components, TypeMatching.Create(env.Options.InterfaceDuckTyping, allowSlicing: true));
Assert.AreNotEqual(TypeMatch.Same, match);
Assert.AreNotEqual(TypeMatch.Substitute, match);
}
return(resolver);
}
public IErrorReporter ErrorMixingSlicingTypes()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true,
AllowProtocols = true
}.SetMutability(mutability));
var root_ns = env.Root;
var system_ns = env.SystemNamespace;
INameReference typename = NameReferenceUnion.Create(new[] {
NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
NameFactory.BoolNameReference()
});
var decl = VariableDeclaration.CreateStatement("foo", typename, initValue: Undef.Create());
var func_def_void = root_ns.AddBuilder(FunctionBuilder.Create(
"notimportant",
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(),
Block.CreateStatement(new[] {
decl,
ExpressionFactory.Readout("foo")
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.MixingSlicingTypes, typename));
}
return(resolver);
}
public IErrorReporter ErrorCastingToSet()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true,
AllowProtocols = true
}.SetMutability(mutability));
var root_ns = env.Root;
NameReferenceUnion type_set = NameReferenceUnion.Create(
NameFactory.PointerNameReference(NameFactory.BoolNameReference()),
NameFactory.PointerNameReference(NameFactory.Int64NameReference()));
root_ns.AddBuilder(FunctionBuilder.Create(
"foo", null,
ExpressionReadMode.OptionalUse,
NameFactory.UnitNameReference(),
Block.CreateStatement(new[] {
VariableDeclaration.CreateStatement("x", NameFactory.IObjectNameReference(), Undef.Create()),
VariableDeclaration.CreateStatement("c", null, ExpressionFactory.DownCast(NameReference.Create("x"), type_set)),
ExpressionFactory.Readout("c"),
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TestingAgainstTypeSet, type_set));
}
return(resolver);
}
