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 ErrorSettingPropertyReferenceField()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowReferenceFields = true
}.SetMutability(mutability));
var root_ns = env.Root;
// this is incorrect we use &Int in setter (OK) but we store this reference in a field too (bad)
Property property = PropertyBuilder.Create(env.Options, "meow",
() => NameFactory.ReferenceNameReference(NameFactory.IntNameReference()))
.WithAutoField(Undef.Create(), EntityModifier.Reassignable)
.WithAutoSetter();
root_ns.AddBuilder(TypeBuilder.Create("whatever")
.SetModifier(EntityModifier.Mutable)
.With(property));
resolver = NameResolver.Create(env);
var setter_assignment = property.Setter.UserBody.Instructions.Single().Cast <Assignment>();
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.EscapingReference, setter_assignment.RhsValue));
}
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 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 PassingPointers()
{
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;
var decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.PointerNameReference(NameFactory.RealNameReference()),
initValue: Undef.Create(), modifier: EntityModifier.Public);
var decl_dst = VariableDeclaration.CreateStatement("bar", NameFactory.PointerNameReference(NameFactory.IObjectNameReference()),
initValue: NameReference.Create("foo"), 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 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 ErrorTestingMismatchedTypes()
{
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.Int64NameReference()));
var decl_src = VariableDeclaration.CreateStatement("foo", NameFactory.PointerNameReference(NameFactory.RealNameReference()),
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(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.TypeMismatch, is_type));
}
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 CircularPointerNesting()
{
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(NameDefinition.Create("Shape"))
.With(FunctionBuilder.Create("reader", NameFactory.UnitNameReference(),
Block.CreateStatement(ExpressionFactory.Readout(NameReference.CreateThised("s")))))
.With(VariableDeclaration.CreateStatement("s", NameFactory.PointerNameReference(NameReference.Create("Form")),
Undef.Create(), EntityModifier.Private)));
root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Form"))
.With(FunctionBuilder.Create("reader", NameFactory.UnitNameReference(),
Block.CreateStatement(ExpressionFactory.Readout(NameReference.CreateThised("f")))))
.With(VariableDeclaration.CreateStatement("f", NameFactory.PointerNameReference(NameReference.Create("Shape")),
Undef.Create(), EntityModifier.Private)));
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 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 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 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);
}
/*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 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 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 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);
}
