public IErrorReporter TypeTesting()
{
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.RealNameReference()));
var decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.PointerNameReference(NameFactory.IObjectNameReference()),
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(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 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 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 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);
}
public IErrorReporter ForcingConstIndirectly()
{
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("Mangler")
.SetModifier(EntityModifier.Mutable)
.With(VariableDeclaration.CreateStatement("f",
NameFactory.PointerNameReference(NameReference.Create("Mutator", NameReference.Create("Stone"))),
Undef.Create(),
EntityModifier.Public))
);
root_ns.AddBuilder(TypeBuilder.Create("Keeper")
.With(VariableDeclaration.CreateStatement("f",
NameFactory.PointerNameReference(NameReference.Create(TypeMutability.ForceConst, "Mangler")),
Undef.Create(),
EntityModifier.Public))
);
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
}
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 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);
}
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 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 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 ErrorIfScope()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DiscardingAnyExpressionDuringTests = true,
}.SetMutability(mutability));
var root_ns = env.Root;
NameReference bad_ref = NameReference.Create("x");
root_ns.AddBuilder(FunctionBuilder.Create(
"testing",
NameFactory.UnitNameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("b", NameFactory.BoolNameReference(), Undef.Create(),
env.Options.ReassignableModifier()),
IfBranch.CreateIf(VariableDeclaration.CreateExpression("x", null, BoolLiteral.CreateTrue()),
// x is in scope
Assignment.CreateStatement("b", "x"),
IfBranch.CreateElse(
// x is in scope as well
Assignment.CreateStatement("b", "x"))),
// here x is not in the scope (is already removed)
Assignment.CreateStatement(NameReference.Create("b"), bad_ref),
ExpressionFactory.Readout("b")
)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ReferenceNotFound, bad_ref));
}
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 InternalIndirectTranslationTables()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
MiniEnvironment = true, DiscardingAnyExpressionDuringTests = true
}.SetMutability(mutability));
var root_ns = env.Root;
const string proxy_typename = "Proxy";
const string proxy_elemtype = "X";
FunctionDefinition get_func = FunctionBuilder.Create("getMe",
ExpressionReadMode.OptionalUse,
NameReference.Create(proxy_elemtype),
Block.CreateStatement(Return.Create(Undef.Create())));
TypeDefinition proxy = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(proxy_typename,
TemplateParametersBuffer.Create(proxy_elemtype).Values))
.With(get_func));
const string parent_typename = "Oldman";
const string parent_elemtype = "PT";
FunctionDefinition access_func = FunctionBuilder.Create("provide",
ExpressionReadMode.OptionalUse,
NameFactory.ReferenceNameReference(NameReference.Create(proxy_typename, NameReference.Create(parent_elemtype))),
Block.CreateStatement(Return.Create(Undef.Create())));
TypeDefinition parent = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(parent_typename,
TemplateParametersBuffer.Create(parent_elemtype).Values))
.SetModifier(EntityModifier.Base)
.With(access_func)
);
const string child_typename = "Kid";
const string child_elemtype = "CT";
FunctionCall call = FunctionCall.Create(NameReference.Create("i", "getMe"));
// with buggy template translation table we would have here a type mismatch error
// if this error happens check first if prefix of the call is evaluated correctly
VariableDeclaration assignment = VariableDeclaration.CreateStatement("e", NameReference.Create(child_elemtype), call);
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(child_typename,
TemplateParametersBuffer.Create(child_elemtype).Values))
.Parents(NameReference.Create(parent_typename, NameReference.Create(child_elemtype)))
.With(FunctionBuilder.Create("process",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement(
VariableDeclaration.CreateStatement("i",
NameFactory.ReferenceNameReference(NameReference.Create(proxy_typename, NameReference.Create(child_elemtype))),
FunctionCall.Create(NameReference.CreateThised("provide"))),
ExpressionFactory.Readout("i"),
assignment,
ExpressionFactory.Readout("e")
))));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, 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 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 InternalDirectTranslationTables()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
MiniEnvironment = true
}.SetMutability(mutability));
var root_ns = env.Root;
const string parent_typename = "Oldman";
const string parent_elemtype = "PT";
FunctionDefinition base_func = FunctionBuilder.CreateDeclaration("getMe",
ExpressionReadMode.CannotBeRead,
NameFactory.ReferenceNameReference(parent_elemtype));
TypeDefinition parent = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(parent_typename,
TemplateParametersBuffer.Create(parent_elemtype).Values))
.SetModifier(EntityModifier.Abstract)
.With(base_func));
const string child_typename = "Kid";
const string child_elemtype = "CT";
FunctionDefinition deriv_func = FunctionBuilder.Create("getMe",
ExpressionReadMode.CannotBeRead,
NameFactory.ReferenceNameReference(child_elemtype),
Block.CreateStatement(Return.Create(Undef.Create())))
.SetModifier(EntityModifier.Override);
TypeDefinition child = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create(child_typename,
TemplateParametersBuffer.Create(child_elemtype).Values))
.Parents(NameReference.Create(parent_typename, NameReference.Create(child_elemtype)))
.With(deriv_func));
resolver = NameResolver.Create(env);
// testing here template translation
EntityInstance child_ancestor = child.Inheritance.OrderedAncestorsWithoutObject.Single();
IEntityInstance translated = base_func.ResultTypeName.Evaluation.Components.TranslateThrough(child_ancestor);
// we have single function overriden, so it is easy to debug and spot if something goes wrong
bool result = FunctionDefinitionExtension.IsDerivedOf(resolver.Context, deriv_func, base_func, child_ancestor);
Assert.IsTrue(result);
}
return(resolver);
}
