public static StructBody TypeBodyDefinition(SourceCodeBody src, StructNode sn) { var body = new StructBody(src, sn.Name.Name); sn.Generics.Each(x => body.Generics.Add(new TypeGenericsParameter(x.Name))); FunctionBodyDefinition(body, sn.Statements); sn.Statements.Each(let => { switch (let) { case LetNode x: body.Members.Add(x.Var.Name, body.LexicalScope[x.Var.Name]); break; case LetTypeNode x: body.Members.Add(x.Var.Name, body.LexicalScope[x.Var.Name]); break; default: throw new Exception(); } }); if (sn.Generics.Count == 0) { body.SpecializationMapper[new GenericsMapper()] = new TypeMapper(); src.Functions.Add(new EmbeddedFunction(sn.Name.Name, sn.Name.Name) { OpCode = (args) => $"newobj instance void {sn.Name.Name}::.ctor()" }); } return(body); }
public ReadOnlyStructPropertyCollection(StructBody body) { properties = body.Properties.ToArray(property => new ReadOnlyStructProperty(property)); autoProperties = body.AutoProperties.ToArray(property => new ReadOnlyStructAutoProperty(property)); lambdaProperties = body.LambdaProperties.ToArray(property => new ReadOnlyStructLambdaProperty(property)); explicitInterfaceProperties = body.ExplicitInterfaceProperties.ToArray(property => new ReadOnlyExplicitInterfaceProperty(property)); }
public ClassNestedStruct(string name) { Name = name; Attributes = new Collection<AttributeGroup>(); Body = new StructBody(); GenericParameters = new Collection<GenericParameter>(); Interfaces = new Collection<InterfaceReference>(); }
public ReadOnlyStructEventCollection(StructBody structBody) { List <ReadOnlyStructEvent> events = new List <ReadOnlyStructEvent>(); List <ReadOnlyStructEvent> eventProperties = new List <ReadOnlyStructEvent>(); this.events = events; this.eventProperties = eventProperties; InitializeEvents(structBody, events, eventProperties); explicitInterfaceEvents = structBody.ExplicitInterfaceEvents.ToArray(@event => new ReadOnlyExplicitInterfaceEvent(@event)); }
public static bool StructBodyInference(StructBody body) { var resolved = false; var keys = body.SpecializationMapper.Keys.ToArray(); for (var i = 0; i < keys.Length; i++) { var value = body.SpecializationMapper[keys[i]]; body.Body.Each(x => resolved = OperandTypeInference(body.Namespace, value, x) || resolved); } return(resolved); }
public static void AssemblyStructEmit(ILWriter il, StructBody body, List <FunctionSpecialization> fss) { var cache = new HashSet <string>(); body.SpecializationMapper.Each(sp => { var g = sp.Key; var mapper = sp.Value; var name = GetStructName(body.Name, body, g); if (cache.Contains(name)) { return; } cache.Add(name); il.WriteLine($".class public {name}"); il.WriteLine("{"); il.Indent++; body.Members.Each(x => il.WriteLine($".field public {GetTypeName(mapper, x.Value, g)} {EscapeILName(x.Key)}")); il.WriteLine(""); il.WriteLine($".method public void .ctor()"); il.WriteLine("{"); il.Indent++; var local_vals = mapper.Values.Where(x => x.Type == VariableType.LocalVariable && !(x.Struct is NamespaceBody)).Sort((a, b) => a.Index - b.Index).ToList(); local_vals.Each((x, i) => x.Index = i); if (local_vals.Count > 0) { il.WriteLine(".locals("); il.Indent++; il.WriteLine(local_vals.Map(x => $"[{x.Index}] {GetTypeName(x, g)} {x.Name}").Join(",\n")); il.Indent--; il.WriteLine(")"); } var labels = Lookup.AllLabels(body.Body).Zip(Lists.Sequence(1)).ToDictionary(x => x.First, x => $"_{x.First.Name}{x.Second}"); body.Body.Each(x => { if (x is Call call) { CallToAddEmitFunctionList(mapper, call, fss); } AssemblyOperandEmit(il, x, body.Namespace, mapper, labels, g); }); il.WriteLine("ret"); il.Indent--; il.WriteLine("}"); il.Indent--; il.WriteLine("}"); }); }
private void InitializeEvents(StructBody structBody, List <ReadOnlyStructEvent> events, List <ReadOnlyStructEvent> eventProperties) { foreach (StructEvent structEvent in structBody.Events) { ReadOnlyStructEvent @event = new ReadOnlyStructEvent(structEvent); if (structEvent.IsEventProperty) { eventProperties.Add(@event); } else { events.Add(@event); } } }
public ReadOnlyStructBody(StructBody structBody) { Classes = new ReadOnlyStructNestedClassCollection(structBody); Constructors = new ConstructorNotSupported[0]; ConversionOperators = structBody.ConversionOperators .ToArray(conversionOperator => new ReadOnlyConversionOperator(conversionOperator)); Delegates = structBody.NestedDelegates.ToArray(nestedDelegate => new ReadOnlyStructNestedDelegate(nestedDelegate)); Enums = structBody.NestedEnums.ToArray(nestedEnum => new ReadOnlyStructNestedEnum(nestedEnum)); Events = new ReadOnlyStructEventCollection(structBody); Fields = new ReadOnlyStructFieldCollection(structBody); Indexers = new ReadOnlyStructIndexerCollection(structBody); Interfaces = structBody.NestedInterfaces.ToArray(@interface => new ReadOnlyStructNestedInterface(@interface)); Methods = new ReadOnlyStructMethodCollection(structBody); OperatorOverloads = structBody.BinaryOperators.Select(@operator => new ReadOnlyOperatorOverload(@operator)) .Concat(structBody.UnaryOperators.Select(@operator => new ReadOnlyOperatorOverload(@operator))) .ToArray(); Properties = new ReadOnlyStructPropertyCollection(structBody); Structs = new ReadOnlyStructNestedStructCollection(structBody); }
public static StructBody TupleDefinition(RootNamespace root, int count) { var name = GetTupleName(count); var exists = root.Structs.FindFirstOrNull(x => x.Name == name); if (exists is StructBody sb) { return(sb); } var body = new StructBody(root, name); Lists.RangeTo(1, count).Each(i => { var gp = new TypeGenericsParameter($"a{i}"); body.Generics.Add(gp); var member = new VariableValue($"{i}"); body.LexicalScope.Add(member.Name, member); body.Body.Add(new TypeBind(member, gp)); body.Members.Add(member.Name, member); }); root.Structs.Add(body); return(body); }
public static bool TypeInference(StructBody body) { var resolved = StructBodyInference(body); SpecializationNumericDecide(body); _ = StructBodyInference(body); VariableValue self; if (body.LexicalScope.ContainsKey("$self")) { self = body.LexicalScope["$self"].Cast <VariableValue>(); } else { self = new VariableValue("$self"); body.LexicalScope.Add(self.Name, self); } foreach (var mapper in body.SpecializationMapper.Values) { if (!mapper.ContainsKey(self)) { mapper[self] = CreateVariableDetail(self.Name, new StructSpecialization(body, Lookup.TypeMapperToGenericsMapper(mapper)), VariableType.Argument, 0); } body.Members.Values.Each(x => { var d = mapper[x]; d.Type = VariableType.Property; d.Reciever = self; d.Index = 0; }); } return(resolved); }
public ReadOnlyStructIndexerCollection(StructBody body) { indexers = body.Indexers.ToArray(indexer => new ReadOnlyStructIndexer(indexer)); explicitInterfaceIndexers = body.ExplicitInterfaceIndexers.ToArray(indexer => new ReadOnlyExplicitInterfaceIndexer(indexer)); }
public ReadOnlyStructFieldCollection(StructBody body) { fields = body.Fields.ToArray(field => new ReadOnlyStructField(field)); }
public ReadOnlyStructNestedClassCollection(StructBody structBody) { classes = structBody.NestedClasses.ToArray(@class => new ReadOnlyStructNestedClass(@class)); }
public ReadOnlyStructMethodCollection(StructBody body) { methods = body.Methods.ToArray(method => new ReadOnlyStructMethod(method)); explicitInterfaceMethods = body.ExplicitInterfaceMethods.ToArray(method => new ReadOnlyExplicitInterfaceMethod(method)); }
public ReadOnlyStructNestedStructCollection(StructBody structBody) { structs = structBody.NestedStructs.ToArray(@struct => new ReadOnlyStructNestedStruct(@struct)); }