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); }