private void createNewConstructors()
{
NameReference type_name = this.Name.CreateNameReference(null, this.InstanceOf, isLocal: true);
if (!this.NestedFunctions.Any(it => it.IsNewConstructor()))
{
foreach (FunctionDefinition init_cons in this.NestedFunctions.Where(it => it.IsInitConstructor()).StoreReadOnly())
{
//if (this.NestedFunctions.Any(it => it.IsNewConstructor()
// && it.Name.Arity == init_cons.Name.Arity && it.NOT_USED_CounterpartParameters(init_cons)))
//continue;
const string local_this = "__this__";
var new_cons = FunctionDefinition.CreateHeapConstructor(init_cons.Modifier, init_cons.Parameters,
type_name,
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement(local_this, null, Alloc.Create(type_name, useHeap: true)),
FunctionCall.Create(NameReference.Create(NameReference.Create(local_this), NameFactory.InitConstructorName),
init_cons.Parameters.Select(it => FunctionArgument.Create(it.Name.CreateNameReference())).ToArray()),
Return.Create(NameReference.Create(local_this))
}));
this.AddNode(new_cons);
}
}
}
public IInterpreter RawMethods()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
Return.Create(FunctionCall.Create(NameReference.Create(Int64Literal.Create("1"), NameFactory.AddOperator),
FunctionArgument.Create(Int64Literal.Create("1"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, 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 IInterpreter ChannelDeadLockOnSend()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("ch", null,
ExpressionFactory.HeapConstructor(NameFactory.ChannelNameReference(NameFactory.Int64NameReference()))),
ExpressionFactory.Readout(FunctionCall.Create(NameReference.Create("ch", NameFactory.ChannelSend),
FunctionArgument.Create(Int64Literal.Create("2")))),
Return.Create(Int64Literal.Create("0"))
})));
int task_id = Task.WaitAny(Task.Delay(TimeSpan.FromSeconds(Interpreter.Interpreter.TimeoutSeconds)), interpreter.TestRunAsync(env));
Assert.AreEqual(0, task_id);
}
return(interpreter);
}
public IInterpreter Indexer()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
IEnumerable <FunctionParameter> property_parameters = new[] { FunctionParameter.Create("idx", NameFactory.Int64NameReference()) };
NameReference property_typename = NameFactory.Int64NameReference();
var point_type = root_ns.AddBuilder(TypeBuilder.Create("Point")
.SetModifier(EntityModifier.Mutable)
.With(Property.CreateIndexer(env.Options, property_typename,
new[] { VariableDeclaration.CreateStatement("x", NameFactory.Int64NameReference(), Int64Literal.Create("1"),
env.Options.ReassignableModifier()) },
new[] { Property.CreateIndexerGetter(property_typename, property_parameters,
Block.CreateStatement(IfBranch.CreateIf(ExpressionFactory.IsEqual(NameReference.Create("idx"), Int64Literal.Create("17")), new[] {
Return.Create(NameReference.CreateThised("x"))
}, IfBranch.CreateElse(new[] {
Return.Create(Int64Literal.Create("300"))
})))) },
new[] { Property.CreateIndexerSetter(property_typename, property_parameters,
Block.CreateStatement(IfBranch.CreateIf(ExpressionFactory.IsEqual(NameReference.Create("idx"), Int64Literal.Create("17")), new[] {
Assignment.CreateStatement(NameReference.CreateThised("x"),
NameReference.Create(NameFactory.PropertySetterValueParameter))
}))) }
)));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// p = Point() // p.x is initialized with 1
VariableDeclaration.CreateStatement("p", null, ExpressionFactory.StackConstructor(NameReference.Create("Point"))),
// p[17] = 1+p[17]
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("p"),
FunctionArgument.Create(Int64Literal.Create("17"))),
FunctionCall.Create(NameReference.Create(Int64Literal.Create("1"), NameFactory.AddOperator),
FunctionArgument.Create(FunctionCall.Indexer(NameReference.Create("p"),
FunctionArgument.Create(Int64Literal.Create("17")))))),
// return p[17]
Return.Create(FunctionCall.Indexer(NameReference.Create("p"),
FunctionArgument.Create(Int64Literal.Create("17"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter MinLimitVariadicFunctionWithSpread()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"sum",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// let i0 = n.at(0)
VariableDeclaration.CreateStatement("i0", null, FunctionCall.Create(NameReference.Create("n", NameFactory.PropertyIndexerName),
FunctionArgument.Create(NatLiteral.Create("0")))),
// let i1 = n.at(1)
VariableDeclaration.CreateStatement("i1", null, FunctionCall.Create(NameReference.Create("n", NameFactory.PropertyIndexerName),
FunctionArgument.Create(NatLiteral.Create("1")))),
// return i0+i1
Return.Create(ExpressionFactory.Add("i0", "i1"))
}))
.Parameters(FunctionParameter.Create("n", NameFactory.Int64NameReference(), Variadic.Create(2), null, isNameRequired: false)));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.HeapConstructor(NameFactory.ChunkNameReference(NameFactory.Int64NameReference()),
FunctionArgument.Create(NatLiteral.Create("2"))),
env.Options.ReassignableModifier()),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("x"), FunctionArgument.Create(NatLiteral.Create("0"))),
Int64Literal.Create("-6")),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("x"), FunctionArgument.Create(NatLiteral.Create("1"))),
Int64Literal.Create("8")),
Return.Create(FunctionCall.Create(NameReference.Create("sum"),
FunctionArgument.Create(Spread.Create(NameReference.Create("x")))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter OverridingMethodWithIndexerGetter()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(TypeBuilder.CreateInterface("IProvider")
.With(FunctionBuilder.CreateDeclaration(NameFactory.PropertyIndexerName, ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference())
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference()))));
root_ns.AddBuilder(TypeBuilder.Create("Middle")
.Parents("IProvider")
.SetModifier(EntityModifier.Base)
.With(FunctionBuilder.Create(NameFactory.PropertyIndexerName, ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(),
Block.CreateStatement(Return.Create(Int64Literal.Create("500"))))
.SetModifier(EntityModifier.Override | EntityModifier.UnchainBase)
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead))));
root_ns.AddBuilder(TypeBuilder.Create("Last")
.Parents("Middle")
.SetModifier(EntityModifier.Base)
.With(PropertyBuilder.CreateIndexer(env.Options, NameFactory.Int64NameReference())
.Parameters(FunctionParameter.Create("x", NameFactory.Int64NameReference(), ExpressionReadMode.CannotBeRead))
.With(PropertyMemberBuilder.CreateIndexerGetter(Block.CreateStatement(Return.Create(Int64Literal.Create("2"))))
.Modifier(EntityModifier.Override | EntityModifier.UnchainBase))));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("p", NameFactory.PointerNameReference("IProvider"),
ExpressionFactory.HeapConstructor("Last")),
Return.Create(FunctionCall.Create(NameReference.Create("p", NameFactory.PropertyIndexerName),
FunctionArgument.Create(Int64Literal.Create("18"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter DirectRefCountings()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DebugThrowOnError = true, AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
var inc_def = root_ns.AddBuilder(FunctionBuilder.Create(
"inc",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// let temp *Int = n; // n is argument
VariableDeclaration.CreateStatement("temp", NameFactory.PointerNameReference(NameFactory.Int64NameReference()),
NameReference.Create("n")),
// return temp + 1;
Return.Create(FunctionCall.Create(NameReference.Create(NameReference.Create("temp"), NameFactory.AddOperator),
FunctionArgument.Create(Int64Literal.Create("1"))))
}))
.Parameters(FunctionParameter.Create("n", NameFactory.PointerNameReference(NameFactory.Int64NameReference()))));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// let p_int *Int = new *1;
VariableDeclaration.CreateStatement("p_int", NameFactory.PointerNameReference(NameFactory.Int64NameReference()),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), FunctionArgument.Create(Int64Literal.Create("1")))),
// let proxy *Int = p_int;
VariableDeclaration.CreateStatement("proxy", NameFactory.PointerNameReference(NameFactory.Int64NameReference()), NameReference.Create("p_int")),
// return inc(proxy);
Return.Create(FunctionCall.Create(NameReference.Create("inc"), FunctionArgument.Create(NameReference.Create("proxy")))),
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter DistinctTypesOverloadCall()
{
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;
var func_def1 = 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(), usageMode: ExpressionReadMode.CannotBeRead)));
var func_def2 = root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new[] {
Return.Create(RealLiteral.Create("3.3"))
}))
.Parameters(FunctionParameter.Create("x", NameFactory.RealNameReference(), usageMode: ExpressionReadMode.CannotBeRead)));
root_ns.AddNode(VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(), Undef.Create()));
root_ns.AddNode(VariableDeclaration.CreateStatement("s", NameFactory.RealNameReference(), Undef.Create()));
var call1 = FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(NameReference.Create("i")));
var call2 = FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(NameReference.Create("s")));
root_ns.AddNode(VariableDeclaration.CreateStatement("x", NameFactory.RealNameReference(),
call1, modifier: EntityModifier.Public));
root_ns.AddNode(VariableDeclaration.CreateStatement("y", NameFactory.RealNameReference(),
call2, modifier: EntityModifier.Public));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
Assert.AreEqual(func_def1, call1.Resolution.TargetFunctionInstance.Target);
Assert.AreEqual(func_def2, call2.Resolution.TargetFunctionInstance.Target);
}
return(resolver);
}
public static void TrapClosure(this ILambdaTransfer node, ComputationContext ctx, ref IExpression source)
{
if (TrapLambdaClosure(node, ctx, ref source))
{
return;
}
if (source is NameReference name_ref && name_ref.Binding.Match.Instance.Target is FunctionDefinition func)
{
if (func.Name.Arity > 0 && !name_ref.TemplateArguments.Any())
{
ctx.AddError(ErrorCode.SelectingAmbiguousTemplateFunction, name_ref);
}
IExpression this_obj = name_ref.GetContext(func);
// example scenario
// f = my_object.my_square
// f(4)
// so we have to grab "my_object", make closure around it, and then put it instead of "my_object.my_square"
name_ref.DetachFrom(node);
if (name_ref.Prefix != null)
{
name_ref.Prefix.DetachFrom(name_ref);
name_ref.Prefix.DereferencedCount_LEGACY = 0; // we have to clear it because we will reuse it
}
TypeDefinition closure_type = buildTypeOfReference(ctx, name_ref, this_obj);
node.AddClosure(closure_type);
if (this_obj != null)
{
source = ExpressionFactory.HeapConstructor(closure_type.InstanceOf.NameOf,
FunctionArgument.Create(name_ref.Prefix));
}
else
{
source = ExpressionFactory.HeapConstructor(closure_type.InstanceOf.NameOf);
}
source.AttachTo(node);
closure_type.Surfed(ctx);
closure_type.Evaluated(ctx, EvaluationCall.AdHocCrossJump);
closure_type.InvokeFunctions().First().MetaThisParameter.Evaluated(ctx, EvaluationCall.AdHocCrossJump);
source.Evaluated(ctx, EvaluationCall.Nested);
}
}
public IInterpreter DereferenceOnAssignment()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DebugThrowOnError = true,
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// p_int *Int = new Int(1)
VariableDeclaration.CreateStatement("p_int", NameFactory.PointerNameReference(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability())),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability()),
FunctionArgument.Create(Int64Literal.Create("1"))), env.Options.ReassignableModifier()),
// v_int Int = *p_int // automatic dereference
VariableDeclaration.CreateStatement("v_int", NameFactory.Int64NameReference(), NameReference.Create("p_int")),
// z_int Int
VariableDeclaration.CreateStatement("z_int", NameFactory.Int64NameReference(), null, env.Options.ReassignableModifier()),
// z_int = *p_int // automatic derereference
Assignment.CreateStatement(NameReference.Create("z_int"), NameReference.Create("p_int")),
// p_int = new Int(77)
Assignment.CreateStatement(NameReference.Create("p_int"),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability()),
FunctionArgument.Create(Int64Literal.Create("77")))),
// return v_int + z_int
Return.Create(FunctionCall.Create(NameReference.Create(NameReference.Create("v_int"), NameFactory.AddOperator),
FunctionArgument.Create(NameReference.Create("z_int"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ErrorSpawningMutables()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
var point_type = root_ns.AddBuilder(TypeBuilder.Create("Point")
.SetModifier(EntityModifier.Mutable)
.With(VariableDeclaration.CreateStatement("x", NameFactory.Int64NameReference(), null,
EntityModifier.Public | env.Options.ReassignableModifier()))
.With(FunctionBuilder.Create("empty",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement())
.Parameters(FunctionParameter.Create("p", NameFactory.PointerNameReference(NameReference.Create("Point")), Variadic.None,
null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead))));
FunctionArgument mutable_arg = FunctionArgument.Create(NameReference.Create("r"));
NameReference mutable_method = NameReference.Create("r", "empty");
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("r", null, ExpressionFactory.HeapConstructor(NameReference.Create("Point"))),
Spawn.Create(FunctionCall.Create(mutable_method, mutable_arg)),
Return.Create(NameReference.Create("r", "x"))
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(2, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotSpawnWithMutableArgument, mutable_arg));
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.CannotSpawnOnMutableContext, mutable_method));
}
return(resolver);
}
public IInterpreter SingleMessage()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"sender",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement(new IExpression[] {
ExpressionFactory.AssertTrue(FunctionCall.Create(NameReference.Create("ch", NameFactory.ChannelSend),
FunctionArgument.Create(Int64Literal.Create("2")))),
}))
.Parameters(FunctionParameter.Create("ch", NameFactory.PointerNameReference(NameFactory.ChannelNameReference(NameFactory.Int64NameReference())),
Variadic.None, null, isNameRequired: false)));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("ch", null,
ExpressionFactory.HeapConstructor(NameFactory.ChannelNameReference(NameFactory.Int64NameReference()))),
Spawn.Create(FunctionCall.Create(NameReference.Create("sender"), FunctionArgument.Create(NameReference.Create("ch")))),
VariableDeclaration.CreateStatement("r", null,
FunctionCall.Create(NameReference.Create("ch", NameFactory.ChannelReceive))),
ExpressionFactory.AssertOptionIsSome(NameReference.Create("r")),
Return.Create(ExpressionFactory.GetOptionValue(NameReference.Create("r")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter AutoProperties()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
var point_type = root_ns.AddBuilder(TypeBuilder.Create("Point")
.SetModifier(EntityModifier.Mutable)
.With(Property.Create(env.Options, "x", NameFactory.Int64NameReference(),
new[] { Property.CreateAutoField(NameFactory.PropertyAutoField, NameFactory.Int64NameReference(), Int64Literal.Create("1"),
env.Options.ReassignableModifier()) },
new[] { Property.CreateAutoGetter(NameFactory.PropertyAutoField, NameFactory.Int64NameReference()) },
new[] { Property.CreateAutoSetter(NameFactory.PropertyAutoField, NameFactory.Int64NameReference()) }
)));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// p = Point() // p.x is initialized with 1
VariableDeclaration.CreateStatement("p", null, ExpressionFactory.StackConstructor(NameReference.Create("Point"))),
// p.x = 1+p.x
Assignment.CreateStatement(NameReference.Create(NameReference.Create("p"), "x"),
FunctionCall.Create(NameReference.Create(Int64Literal.Create("1"), NameFactory.AddOperator),
FunctionArgument.Create(NameReference.Create("p", "x")))),
// return p.x
Return.Create(NameReference.Create("p", "x"))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter ClosureRecursiveCall()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
IExpression i_eq_jack = ExpressionFactory.IsEqual(NameReference.Create("i"), NameReference.Create("jack"));
IExpression i_add_1 = ExpressionFactory.Add(NameReference.Create("i"), Nat8Literal.Create("1"));
FunctionDefinition lambda = FunctionBuilder.CreateLambda(NameFactory.Nat8NameReference(),
Block.CreateStatement(new[] {
// if i==jack then return i
IfBranch.CreateIf(i_eq_jack, new[] { Return.Create(NameReference.Create("i")) },
// else return self(i+1)
IfBranch.CreateElse(new[] {
Return.Create(FunctionCall.Create(NameReference.Create(NameFactory.RecurFunctionName),
FunctionArgument.Create(i_add_1)))
}))
}))
.Parameters(FunctionParameter.Create("i", NameFactory.Nat8NameReference()));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("jack", null, Nat8Literal.Create("50")),
// Immediately-Invoked Function Expression (IIEFE) in Javascript world
Return.Create(FunctionCall.Create(lambda, FunctionArgument.Create(Nat8Literal.Create("0"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)50, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter RecursiveCall()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
IExpression i_eq_2 = ExpressionFactory.IsEqual(NameReference.Create("i"), Int64Literal.Create("2"));
IExpression i_add_1 = ExpressionFactory.Add(NameReference.Create("i"), Int64Literal.Create("1"));
root_ns.AddBuilder(FunctionBuilder.Create("foo",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
// if i==2 then return i
IfBranch.CreateIf(i_eq_2, new[] { Return.Create(NameReference.Create("i")) },
// else return self(i+1)
IfBranch.CreateElse(new[] {
Return.Create(FunctionCall.Create(NameReference.Create(NameFactory.RecurFunctionName),
FunctionArgument.Create(i_add_1)))
}))
}))
.Parameters(FunctionParameter.Create("i", NameFactory.Int64NameReference())));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
Return.Create(FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(Int64Literal.Create("0"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ImplicitValueReferenceConversionOnCall()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement(new[] {
FunctionCall.Create(NameReference.Create("foo"), FunctionArgument.Create(Int64Literal.Create("5")))
})));
root_ns.AddBuilder(FunctionBuilder.Create(
"foo",
ExpressionReadMode.CannotBeRead,
NameFactory.UnitNameReference(),
Block.CreateStatement())
.Parameters(FunctionParameter.Create("x", NameFactory.ReferenceNameReference(NameFactory.Int64NameReference()),
usageMode: ExpressionReadMode.CannotBeRead)));
resolver = NameResolver.Create(env);
Assert.AreEqual(0, resolver.ErrorManager.Errors.Count);
}
return(resolver);
}
private static TypeDefinition buildTypeOfReference(ComputationContext ctx,
NameReference funcReference, IExpression thisObject)
{
if (funcReference.Owner != null)
{
throw new Exception("Detach it first.");
}
const string meta_this = "mThis";
FunctionDefinition function = funcReference.Binding.Match.Instance.Target.CastFunction();
FunctionDefinition cons;
NameReference func_field_ref;
if (thisObject != null)
{
cons = FunctionDefinition.CreateInitConstructor(EntityModifier.None,
new[] { FunctionParameter.Create(meta_this, thisObject.Evaluation.Components.NameOf) },
Block.CreateStatement(
new[] {
Assignment.CreateStatement(NameReference.Create(NameFactory.ThisVariableName, meta_this),
NameReference.Create(meta_this)),
}));
func_field_ref = NameReference.Create(NameFactory.ThisVariableName, meta_this);
}
else
{
func_field_ref = null;
cons = null;
}
IEnumerable <FunctionParameter> trans_parameters = function.Parameters.Select(pit =>
FunctionParameter.Create(pit.Name.Name, pit.TypeName.Evaluated(ctx, EvaluationCall.AdHocCrossJump)
.TranslateThrough(funcReference.Binding.Match.Instance).NameOf));
FunctionDefinition invoke = FunctionBuilder.Create(NameFactory.LambdaInvoke, ExpressionReadMode.ReadRequired,
function.ResultTypeName,
Block.CreateStatement(new[] {
Return.Create(FunctionCall.Create(
NameReference.Create(func_field_ref, funcReference.Name,
funcReference.TemplateArguments.Select(it => it.TypeName).ToArray()),
function.Parameters.Select(it => FunctionArgument.Create(NameReference.Create(it.Name.Name))).ToArray()))
}))
.SetModifier(EntityModifier.Override)
.Parameters(trans_parameters.ToArray());
TypeBuilder closure_builder = TypeBuilder.Create(NameDefinition.Create(AutoName.Instance.CreateNew("Closure")))
.With(invoke)
.Parents(invoke.CreateFunctionInterface());
if (thisObject != null)
{
VariableDeclaration this_field = VariableDeclaration.CreateStatement(meta_this,
thisObject.Evaluation.Components.NameOf, Undef.Create());
closure_builder
.With(cons)
.With(this_field);
TypeMutability mutability = thisObject.Evaluation.Components.MutabilityOfType(ctx);
if (mutability == TypeMutability.ForceMutable)
{
closure_builder.SetModifier(EntityModifier.Mutable);
}
else if (mutability != TypeMutability.ConstAsSource)
{
throw new NotImplementedException();
}
}
return(closure_builder);
}
public IInterpreter DereferenceOnIfCondition()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
DebugThrowOnError = true,
AllowInvalidMainResult = true
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("ptr", NameFactory.PointerNameReference(NameFactory.BoolNameReference()),
ExpressionFactory.HeapConstructor(NameFactory.BoolNameReference(), FunctionArgument.Create(BoolLiteral.CreateTrue()))),
Return.Create(IfBranch.CreateIf(NameReference.Create("ptr"), new[] { Int64Literal.Create("2") },
IfBranch.CreateElse(new[] { Int64Literal.Create("5") }))),
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IErrorReporter ErrorHasConstraint()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true, AllowProtocols = true
}.SetMutability(mutability));
var root_ns = env.Root;
FunctionDefinition func_constraint = FunctionBuilder.CreateDeclaration("getMe",
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference());
// this function accepts any parameter where parameter type has function "getMe"
FunctionDefinition constrained_func = root_ns.AddBuilder(FunctionBuilder.Create("proxy",
TemplateParametersBuffer.Create().Add("T").Values,
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new[] {
Return.Create(FunctionCall.Create(NameReference.Create("t", "getMe")))
}))
.Constraints(ConstraintBuilder.Create("T").Has(func_constraint))
.Parameters(FunctionParameter.Create("t", NameFactory.PointerNameReference("T"))));
// this type does NOT have function "getMe"
TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create("YMan")
.With(FunctionBuilder.Create("missing",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("2"))
}))));
FunctionCall call = FunctionCall.Create(NameReference.Create("proxy"), FunctionArgument.Create(NameReference.Create("y_man")));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("y_man", null, ExpressionFactory.HeapConstructor(NameReference.Create("YMan"))),
Return.Create(call)
})));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ViolatedHasFunctionConstraint, call.Callee));
}
return(resolver);
}
public IInterpreter ExplicitDereferencing()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true,
AllowDereference = true
}.SetMutability(mutability));
var root_ns = env.Root;
VariableDeclaration decl = VariableDeclaration.CreateStatement("x",
NameFactory.PointerNameReference(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability())),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability()),
FunctionArgument.Create(Int64Literal.Create("4"))),
env.Options.ReassignableModifier());
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
// x *Int = new Int(4)
decl,
// y *Int = x
VariableDeclaration.CreateStatement("y",
NameFactory.PointerNameReference(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability())),
NameReference.Create("x")),
// *x = 7 // y <- 7
Assignment.CreateStatement(Dereference.Create(NameReference.Create("x")), Int64Literal.Create("7")),
// z *Int
VariableDeclaration.CreateStatement("z",
NameFactory.PointerNameReference(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability())),
null, env.Options.ReassignableModifier()),
// z = x
Assignment.CreateStatement(NameReference.Create("z"), NameReference.Create("x")),
// v = y + z // 14
VariableDeclaration.CreateStatement("v", null, ExpressionFactory.Add("y", "z"), env.Options.ReassignableModifier()),
// x = -12
Assignment.CreateStatement(NameReference.Create("x"),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability()),
FunctionArgument.Create(Int64Literal.Create("-12")))),
// *z = *x // z <- -12
Assignment.CreateStatement(Dereference.Create(NameReference.Create("z")), Dereference.Create(NameReference.Create("x"))),
// x = -1000
Assignment.CreateStatement(NameReference.Create("x"),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(env.Options.ReassignableTypeMutability()),
FunctionArgument.Create(Int64Literal.Create("-1000")))),
// v = v+z // v = 14 + (-12)
Assignment.CreateStatement(NameReference.Create("v"), ExpressionFactory.Add("v", "z")),
Return.Create(NameReference.Create("v"))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter StoringSequenceAsSequence()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
// todo: add analogous test with storing iterable as sequence
// yes, this test seems like pointless thing but it is important nevertheless because
// we have to check if conversion does NOT happen
var env = Language.Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Nat8NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("x", null,
ExpressionFactory.HeapConstructor(NameFactory.ChunkNameReference(NameFactory.Int64NameReference()),
FunctionArgument.Create(NatLiteral.Create("2"))),
env.Options.ReassignableModifier()),
ExpressionFactory.InitializeIndexable("x", Int64Literal.Create("-6"), Int64Literal.Create("8")),
// conversion should NOT happen
VariableDeclaration.CreateStatement("stored", null,
FunctionCall.Create(NameFactory.StoreFunctionReference(), NameReference.Create("x"))),
Return.Create(ExpressionFactory.Ternary(IsSame.Create("x", "stored"), Nat8Literal.Create("2"), Nat8Literal.Create("7")))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual((byte)2, result.RetValue.PlainValue);
}
return(interpreter);
}
public static IExpression InitializeIndexable(string name, params IExpression[] arguments)
{
return(Block.CreateStatement(arguments.ZipWithIndex().Select(it =>
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create(name),
FunctionArgument.Create(NatLiteral.Create($"{it.Item2}"))),
it.Item1))));
}
public IInterpreter RefCountsOnReadingFunctionCall()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
// the aim of this test is to test heap manager if it correctly handles reading function which returns pointer
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}
.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"provider",
ExpressionReadMode.OptionalUse,
NameFactory.PointerNameReference(NameFactory.Int64NameReference()),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("p_int", null,
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(),
FunctionArgument.Create(Int64Literal.Create("77")))),
Return.Create(NameReference.Create("p_int")),
})));
var main_func = root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("i", NameFactory.Int64NameReference(),
FunctionCall.Create(NameReference.Create("provider"))),
Return.Create(NameReference.Create("i")),
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(77L, result.RetValue.PlainValue);
}
return(interpreter);
}
public static ConstructorCall HeapConstructor(TypeMutability mutability, NameReference innerTypeName, params IExpression[] arguments)
{
return(HeapConstructor(mutability, innerTypeName, arguments.Select(it => FunctionArgument.Create(it)).ToArray()));
}
public static ConstructorCall Constructor(NameReference typeName, Memory memory, params IExpression[] arguments)
{
return(Constructor(typeName, memory, arguments.Select(it => FunctionArgument.Create(it)).ToArray()));
}
public static bool TrapLambdaClosure(this ILambdaTransfer node, ComputationContext ctx, ref IExpression source)
{
if (!(source is FunctionDefinition lambda))
{
return(false);
}
// example scenario
// f = (x) => x*x
// f(4)
// we already have tracked all the variables used inside lambda (which are declared outside, locals are OK),
// so all we have to do it is to remove it and put into closure type
if (!lambda.IsComputed)
{
throw new Exception("Internal error");
}
lambda.DetachFrom(node);
TypeDefinition closure_type = buildTypeOfLambda(ctx, lambda, lambda.LambdaTrap.Fields);
node.AddClosure(closure_type);
source = ExpressionFactory.HeapConstructor(closure_type.InstanceOf.NameOf,
lambda.LambdaTrap.Fields.Select(it => FunctionArgument.Create(NameReference.Create(it.Name.Name))).ToArray());
source.AttachTo(node);
lambda.LambdaTrap = null;
// we have to manually evaluate this expression, because it is child of current node, and child nodes
// are evaluated before their parents
closure_type.Surfed(ctx);
closure_type.Evaluated(ctx, EvaluationCall.AdHocCrossJump);
// todo: this is ugly -- we are breaking into details of separate type
// since the function is already computed, it won't evaluate meta this parameter
lambda.MetaThisParameter.Evaluated(ctx, EvaluationCall.AdHocCrossJump);
source.Evaluated(ctx, EvaluationCall.Nested);
return(true);
}
public IInterpreter StackChunkWithBasicPointers()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
AllowInvalidMainResult = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("chicken", null,
ExpressionFactory.StackConstructor(NameFactory.ChunkNameReference(NameFactory.PointerNameReference(NameFactory.Int64NameReference())),
FunctionArgument.Create(NatLiteral.Create("2")))),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("chicken"), NatLiteral.Create("0")),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("-6"))),
Assignment.CreateStatement(FunctionCall.Indexer(NameReference.Create("chicken"), NatLiteral.Create("1")),
ExpressionFactory.HeapConstructor(NameFactory.Int64NameReference(), Int64Literal.Create("8"))),
Return.Create(ExpressionFactory.Add(FunctionCall.Indexer(NameReference.Create("chicken"), NatLiteral.Create("0")),
FunctionCall.Indexer(NameReference.Create("chicken"), NatLiteral.Create("1"))))
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public IInterpreter HasConstraintWithValue()
{
var interpreter = new Interpreter.Interpreter();
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
AllowInvalidMainResult = true,
AllowProtocols = true,
DebugThrowOnError = true
}.SetMutability(mutability));
var root_ns = env.Root;
FunctionDefinition func_constraint = FunctionBuilder.CreateDeclaration("getMe",
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference());
root_ns.AddBuilder(FunctionBuilder.Create("proxy",
TemplateParametersBuffer.Create().Add("T").Values,
ExpressionReadMode.ReadRequired, NameFactory.Int64NameReference(), Block.CreateStatement(new[] {
Return.Create(FunctionCall.Create(NameReference.Create("t", "getMe")))
}))
.Constraints(ConstraintBuilder.Create("T").Has(func_constraint))
.Parameters(FunctionParameter.Create("t", NameReference.Create("T"))));
TypeDefinition type_impl = root_ns.AddBuilder(TypeBuilder.Create("Y")
.With(FunctionBuilder.Create("getMe",
ExpressionReadMode.ReadRequired,
NameFactory.Int64NameReference(),
Block.CreateStatement(new[] {
Return.Create(Int64Literal.Create("2"))
}))));
FunctionCall call = FunctionCall.Create(NameReference.Create("proxy"), FunctionArgument.Create(NameReference.Create("y")));
root_ns.AddBuilder(FunctionBuilder.Create(
"main",
ExpressionReadMode.OptionalUse,
NameFactory.Int64NameReference(),
Block.CreateStatement(new IExpression[] {
VariableDeclaration.CreateStatement("y", null, ExpressionFactory.StackConstructor(NameReference.Create("Y"))),
Return.Create(call)
})));
ExecValue result = interpreter.TestRun(env);
Assert.AreEqual(2L, result.RetValue.PlainValue);
}
return(interpreter);
}
public static bool DataTransfer(this IEvaluable @this, ComputationContext ctx, ref IExpression source,
IEntityInstance targetTypeName, bool ignoreMutability = false)
{
if (source == null)
{
return(true);
}
IEntityInstance src_type = source.Evaluation.Components;
TypeMatch match = src_type.MatchesTarget(ctx, targetTypeName,
TypeMatching.Create(ctx.Env.Options.InterfaceDuckTyping, allowSlicing: false)
.WithIgnoredMutability(ignoreMutability)
.AllowedLifetimeChecking(true));
if (match.HasFlag(TypeMatch.Attachment))
{
match ^= TypeMatch.Attachment;
}
if (match == TypeMatch.No)
{
ctx.ErrorManager.AddError(ErrorCode.TypeMismatch, source);
return(false);
}
else if (match == TypeMatch.Lifetime)
{
ctx.ErrorManager.AddError(ErrorCode.EscapingReference, source);
return(false);
}
else if (match == TypeMatch.InConversion)
{
source.DetachFrom(@this);
source = ExpressionFactory.StackConstructor((targetTypeName as EntityInstance).NameOf, FunctionArgument.Create(source));
source.AttachTo(@this);
TypeMatch m = source.Evaluated(ctx, EvaluationCall.AdHocCrossJump).MatchesTarget(ctx, targetTypeName, TypeMatching.Create(ctx.Env.Options.InterfaceDuckTyping, allowSlicing: false));
if (m != TypeMatch.Same && m != TypeMatch.Substitute)
{
throw new Exception("Internal error");
}
}
else if (match.HasFlag(TypeMatch.ImplicitReference))
{
match ^= TypeMatch.ImplicitReference;
if (match != TypeMatch.Substitute && match != TypeMatch.Same)
{
throw new NotImplementedException();
}
source.DetachFrom(@this);
source = AddressOf.CreateReference(source);
source.AttachTo(@this);
IEntityInstance source_eval = source.Evaluated(ctx, EvaluationCall.AdHocCrossJump);
TypeMatch m = source_eval.MatchesTarget(ctx, targetTypeName, TypeMatching.Create(ctx.Env.Options.InterfaceDuckTyping,
allowSlicing: true));
if (m != TypeMatch.Same && m != TypeMatch.Substitute)
{
throw new Exception($"Internal error: matching result {m}");
}
}
else if (match == TypeMatch.OutConversion)
{
source.DetachFrom(@this);
source = FunctionCall.ConvCall(source, (targetTypeName as EntityInstance).NameOf);
source.AttachTo(@this);
TypeMatch m = source.Evaluated(ctx, EvaluationCall.AdHocCrossJump).MatchesTarget(ctx, targetTypeName, TypeMatching.Create(ctx.Env.Options.InterfaceDuckTyping, allowSlicing: false));
if (m != TypeMatch.Same && m != TypeMatch.Substitute)
{
throw new Exception("Internal error");
}
}
else if (match.HasFlag(TypeMatch.AutoDereference))
{
source.DereferencedCount_LEGACY = match.Dereferences;
@this.Cast <IExpression>().DereferencingCount = match.Dereferences;
match ^= TypeMatch.AutoDereference;
if (match != TypeMatch.Substitute && match != TypeMatch.Same)
{
throw new NotImplementedException();
}
}
else if (match != TypeMatch.Same && match != TypeMatch.Substitute)
{
throw new NotImplementedException();
}
return(true);
}