private static TypeDefinition buildTypeOfLambda(ComputationContext ctx,
FunctionDefinition lambda, IEnumerable <VariableDeclaration> fields)
{
if (lambda.Owner != null)
{
throw new Exception("Internal error");
}
FunctionDefinition cons = FunctionDefinition.CreateInitConstructor(EntityModifier.None,
fields.Select(it => FunctionParameter.Create(it.Name.Name, it.TypeName)),
Block.CreateStatement(
fields.Select(it
=> Assignment.CreateStatement(NameReference.Create(NameFactory.ThisVariableName, it.Name.Name),
NameReference.Create(it.Name.Name)))
));
lambda.SetModifier(EntityModifier.Override | lambda.Modifier);
TypeDefinition functor = TypeBuilder.Create(NameDefinition.Create(AutoName.Instance.CreateNew("Closure")))
.With(fields)
.With(cons)
.With(lambda)
.Parents(lambda.CreateFunctionInterface());
return(functor);
}
public IErrorReporter ErrorNoDefaultConstructor()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
var bar_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Bar"))
.With(FunctionDefinition.CreateInitConstructor(EntityModifier.None,
new[] { FunctionParameter.Create("a", NameFactory.Int64NameReference(),
Variadic.None, null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead) },
Block.CreateStatement())));
VariableDeclaration field_decl = VariableDeclaration.CreateStatement("x", NameReference.Create("Bar"), null,
EntityModifier.Public);
var type_def = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Point"))
.With(field_decl));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.NoDefaultConstructor, field_decl));
}
return(resolver);
}
public IErrorReporter ErrorCallingConstructorFromBody()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
FunctionCall constructor_call = FunctionCall.Create(NameReference.Create(NameFactory.ThisVariableName,
NameFactory.InitConstructorName));
var type_def = root_ns.AddBuilder(TypeBuilder.Create("Foo")
.SetModifier(EntityModifier.Base)
.With(FunctionDefinition.CreateInitConstructor(EntityModifier.None, null,
Block.CreateStatement()))
.With(FunctionBuilder.Create("foo", null,
ExpressionReadMode.OptionalUse,
NameFactory.RealNameReference(),
Block.CreateStatement(new IExpression[] {
constructor_call,
Return.Create(RealLiteral.Create("3.3"))
}))
.SetModifier(EntityModifier.Base)));
resolver = NameResolver.Create(env);
Assert.AreEqual(1, resolver.ErrorManager.Errors.Count);
Assert.IsTrue(resolver.ErrorManager.HasError(ErrorCode.ConstructorCallFromFunctionBody, constructor_call));
}
return(resolver);
}
public static FunctionDefinition BasicConstructor(string[] names, INameReference[] typenames)
{
return(FunctionDefinition.CreateInitConstructor(EntityModifier.None,
Enumerable.Range(0, names.Length).Select(i => FunctionParameter.Create(names[i], typenames[i])),
Block.CreateStatement(
names.Select(s => Assignment.CreateStatement(NameReference.CreateThised(s), NameReference.Create(s))))));
}
public IErrorReporter CircularConversion()
{
NameResolver resolver = null;
foreach (var mutability in Options.AllMutabilityModes)
{
var env = Language.Environment.Create(new Options()
{
}.SetMutability(mutability));
var root_ns = env.Root;
TypeDefinition type = root_ns.AddBuilder(TypeBuilder.Create(NameDefinition.Create("Foo", "T", VarianceMode.Out))
.Slicing(true)
.With(FunctionDefinition.CreateInitConstructor(EntityModifier.Implicit,
new[] {
// converting itself
FunctionParameter.Create(NameFactory.SourceConvConstructorParameter, NameReference.Create("Foo", NameReference.Create("T")), Variadic.None,
null, isNameRequired: false, usageMode: ExpressionReadMode.CannotBeRead)
},
Block.CreateStatement())
));
var decl = root_ns.AddNode(
VariableDeclaration.CreateStatement("x",
NameReference.Create("Foo", NameFactory.Int64NameReference()), Int64Literal.Create("5")));
resolver = NameResolver.Create(env);
}
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);
}
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);
}
