diff --git a/GAP-LEDGER.md b/GAP-LEDGER.md index 8c16085..b605345 100644 --- a/GAP-LEDGER.md +++ b/GAP-LEDGER.md @@ -4578,4 +4578,34 @@ An operator takes the name and parameter types of a member of an ancestor, a sec None in this run. +### aggregate served by several transitions — 7 + +Several transition functions serve one aggregate name over values of the class, and nothing in the values tells them apart. + +| class | member | what is missing | +| --- | --- | --- | +| Temporal | tCentroid | tpoint_tcentroid_transfn, tnpoint_tcentroid_transfn | +| Temporal | tMaxAgg | tint_tmax_transfn, tbigint_tmax_transfn, tfloat_tmax_transfn, ttext_tmax_transfn | +| Temporal | tMinAgg | tint_tmin_transfn, tbigint_tmin_transfn, tfloat_tmin_transfn, ttext_tmin_transfn | +| Temporal | tSum | tint_tsum_transfn, tbigint_tsum_transfn, tfloat_tsum_transfn | +| Temporal | wMax | tint_wmax_transfn, tbigint_wmax_transfn, tfloat_wmax_transfn | +| Temporal | wMin | tint_wmin_transfn, tbigint_wmin_transfn, tfloat_wmin_transfn | +| Temporal | wSum | tint_wsum_transfn, tbigint_wsum_transfn, tfloat_wsum_transfn | + +### aggregate state not threadable — 0 + +The transition and the final function of the aggregate do not pass one state pointer from call to call. + +None in this run. + +### aggregate argument or result needs marshalling — 3 + +An argument of the transition or the result of the final function has no rule of this generator. + +| class | member | what is missing | +| --- | --- | --- | +| Temporal | appendInstantAgg | temporal_app_tinst_transfn / temporal_append_finalfn | +| Temporal | wAvgAgg | tnumber_wavg_transfn / tnumber_tavg_finalfn | +| Temporal | wCount | temporal_wcount_transfn / temporal_tagg_finalfn | + diff --git a/MEOS.NET.Tests/AggregateTests.cs b/MEOS.NET.Tests/AggregateTests.cs new file mode 100644 index 0000000..444553c --- /dev/null +++ b/MEOS.NET.Tests/AggregateTests.cs @@ -0,0 +1,55 @@ +using MEOS.NET.Types; + +namespace MEOS.NET.Tests +{ + /// + /// An aggregate of the catalog's `aggregates` is a static method of the + /// class of its values: the transition threaded over the values from a NULL + /// state, then the final function. Each answer is the one MobilityDB's + /// 500_raster test states for the same tiles. + /// + [TestClass] + public class AggregateTests : MeosTest + { + // The example of the manual: two 2x2 tiles of one 32BF band, the second + // one pixel east and one south of the first, holding 1 and 3. + private static Raster[] Tiles() => new[] + { + Raster.MakeEmpty(2, 2, 0, 2, 1, -1, 0, 0, 3857)!.AddBand(1, "32BF", 1, -9999, true)!, + Raster.MakeEmpty(2, 2, 1, 1, 1, -1, 0, 0, 3857)!.AddBand(1, "32BF", 3, -9999, true)!, + }; + + [TestMethod] + public void TheUnionOfTwoTilesTakesTheMeanWhereTheyOverlap() + { + Raster union = Raster.RasterUnion(Tiles(), 1, "MEAN")!; + + // {{1,1,NULL},{1,2,3},{NULL,3,3}} + var (values, nodata) = union.DumpValues(1, true); + CollectionAssert.AreEqual( + new[] { false, false, true, false, false, false, true, false, false }, nodata); + CollectionAssert.AreEqual(new[] { 1.0, 1, 1, 2, 3, 3, 3 }, + values.Where((_v, i) => !nodata[i]).ToArray()); + } + + [TestMethod] + public void TheStatisticsOfABandSpanTheTiles() + { + BandStats stats = Raster.SummaryStatsAgg(Tiles(), 1, true)!; + + Assert.AreEqual(8, stats.Count()); + Assert.AreEqual(16.0, stats.Sum()); + Assert.AreEqual(2.0, stats.Mean()); + Assert.AreEqual(1.0, stats.Stddev()); + Assert.AreEqual(1.0, stats.Min()); + Assert.AreEqual(3.0, stats.Max()); + } + + [TestMethod] + public void AnAggregateOverNoValuesIsNull() + { + Assert.IsNull(Raster.RasterUnion(Array.Empty(), 1, "MEAN")); + Assert.IsNull(Raster.SummaryStatsAgg(Array.Empty(), 1, true)); + } + } +} diff --git a/MEOS.NET/Types/CBuffer.g.cs b/MEOS.NET/Types/CBuffer.g.cs index 82a121a..0c84019 100644 --- a/MEOS.NET/Types/CBuffer.g.cs +++ b/MEOS.NET/Types/CBuffer.g.cs @@ -289,5 +289,16 @@ public int Touches(CBuffer cb2) public static CBuffer? Make(Geo point, double radius) => MEOSFactory.WrapCBuffer(Meos.CbufferMake(point.Ptr, radius)); + public static Set? SetUnionAgg(CBuffer[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.CbufferUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/Geo.g.cs b/MEOS.NET/Types/Geo.g.cs index 936871b..ea74dd9 100644 --- a/MEOS.NET/Types/Geo.g.cs +++ b/MEOS.NET/Types/Geo.g.cs @@ -439,6 +439,17 @@ public static int[] ClusterKmeans(Geo[] geoms, uint k) } } + public static Set? SetUnionAgg(Geo[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.GeoUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + public static string? Typename(int type) => Meos.GeoTypename(type); diff --git a/MEOS.NET/Types/Jsonb.g.cs b/MEOS.NET/Types/Jsonb.g.cs index 4168804..3db52c7 100644 --- a/MEOS.NET/Types/Jsonb.g.cs +++ b/MEOS.NET/Types/Jsonb.g.cs @@ -410,5 +410,16 @@ public long ToInt64() } } + public static Set? SetUnionAgg(Jsonb[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.JsonbUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/NPoint.g.cs b/MEOS.NET/Types/NPoint.g.cs index 7c95d1b..995853e 100644 --- a/MEOS.NET/Types/NPoint.g.cs +++ b/MEOS.NET/Types/NPoint.g.cs @@ -199,5 +199,16 @@ public bool SameRid(TNPoint temp) public static NPoint? Make(long rid, double pos) => MEOSFactory.WrapNPoint(Meos.NpointMake(rid, pos)); + public static Set? SetUnionAgg(NPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.NpointUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/PCPatch.g.cs b/MEOS.NET/Types/PCPatch.g.cs index f1a7316..7bdb4bb 100644 --- a/MEOS.NET/Types/PCPatch.g.cs +++ b/MEOS.NET/Types/PCPatch.g.cs @@ -183,5 +183,16 @@ public uint Npoints() } } + public static Set? SetUnionAgg(PCPatch[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.PcpatchUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/PCPoint.g.cs b/MEOS.NET/Types/PCPoint.g.cs index f91cabc..1ec8477 100644 --- a/MEOS.NET/Types/PCPoint.g.cs +++ b/MEOS.NET/Types/PCPoint.g.cs @@ -221,5 +221,16 @@ public bool Ne(PCPoint pt2) } } + public static Set? SetUnionAgg(PCPoint[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.PcpointUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/Pose.g.cs b/MEOS.NET/Types/Pose.g.cs index def305f..aaf2d80 100644 --- a/MEOS.NET/Types/Pose.g.cs +++ b/MEOS.NET/Types/Pose.g.cs @@ -268,5 +268,16 @@ public double[] Ypr() public static Pose? MakePoint3dYpr(Geo gs, double yaw, double pitch, double roll) => MEOSFactory.WrapPose(Meos.PoseMakePoint3dYpr(gs.Ptr, yaw, pitch, roll)); + public static Set? SetUnionAgg(Pose[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.PoseUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/PoseChain.g.cs b/MEOS.NET/Types/PoseChain.g.cs index 66773be..d32bbce 100644 --- a/MEOS.NET/Types/PoseChain.g.cs +++ b/MEOS.NET/Types/PoseChain.g.cs @@ -254,5 +254,16 @@ public int SRID() } } + public static Set? SetUnionAgg(PoseChain[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.PosechainUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/Raster.g.cs b/MEOS.NET/Types/Raster.g.cs index ef166bd..8ecbda0 100644 --- a/MEOS.NET/Types/Raster.g.cs +++ b/MEOS.NET/Types/Raster.g.cs @@ -473,6 +473,39 @@ public static int EValueGdal(Temporal traj, string path, int band, Span vspan) public static Temporal? MinusValueGdal(Temporal traj, string path, int band, Span vspan) => MEOSFactory.WrapTemporal(Meos.RasterMinusValueGdal(traj.Ptr, path, band, vspan.Ptr)); + public static Raster? RasterUnion(Raster[] values, int band, string uniontype) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.RasterUnionTransfn(_state, _v.Ptr, band, uniontype); + } + + return MEOSFactory.WrapRaster(Meos.RasterUnionFinalfn(_state)); + } + + public static bool SameAlignmentAgg(Raster[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.RasterSameAlignmentTransfn(_state, _v.Ptr); + } + + return Meos.RasterSameAlignmentFinalfn(_state); + } + + public static BandStats? SummaryStatsAgg(Raster[] values, int band, bool exclude_nodata) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.RasterSummaryStatsTransfn(_state, _v.Ptr, band, exclude_nodata); + } + + return MEOSFactory.WrapBandStats(Meos.RasterSummaryStatsFinalfn(_state)); + } + public static Temporal? TileAtValue(Temporal traj, RaQuet rq, Span vspan) => MEOSFactory.WrapTemporal(Meos.RasterTileAtValue(traj.Ptr, rq.Ptr, vspan.Ptr)); diff --git a/MEOS.NET/Types/Set.g.cs b/MEOS.NET/Types/Set.g.cs index 581d47b..2df52cd 100644 --- a/MEOS.NET/Types/Set.g.cs +++ b/MEOS.NET/Types/Set.g.cs @@ -174,5 +174,27 @@ public bool Right(Set s2) } } + public static Set? SetUnionAgg(Set[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.SetUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + + public static Temporal? TCount(Set[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TstzsetTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/Span.g.cs b/MEOS.NET/Types/Span.g.cs index 32a35b8..4899ad2 100644 --- a/MEOS.NET/Types/Span.g.cs +++ b/MEOS.NET/Types/Span.g.cs @@ -193,5 +193,27 @@ public bool UpperInc() } } + public static SpanSet? SpanUnionAgg(Span[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.SpanUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSpanSet(Meos.SpansetUnionFinalfn(_state)); + } + + public static Temporal? TCount(Span[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TstzspanTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/SpanSet.g.cs b/MEOS.NET/Types/SpanSet.g.cs index f4da7f2..b57f506 100644 --- a/MEOS.NET/Types/SpanSet.g.cs +++ b/MEOS.NET/Types/SpanSet.g.cs @@ -246,5 +246,27 @@ public bool UpperInc() } } + public static SpanSet? SpansetUnionAgg(SpanSet[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.SpansetUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSpanSet(Meos.SpansetUnionFinalfn(_state)); + } + + public static Temporal? TCount(SpanSet[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TstzspansetTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/Temporal.g.cs b/MEOS.NET/Types/Temporal.g.cs index cd4ec8b..7787805 100644 --- a/MEOS.NET/Types/Temporal.g.cs +++ b/MEOS.NET/Types/Temporal.g.cs @@ -587,6 +587,17 @@ public bool UpperInc() public Set? Valueset() => MEOSFactory.WrapSet(Meos.TemporalValueset(this.Ptr)); + public static Temporal? AppendSequenceAgg(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalAppTseqTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalAppendFinalfn(_state)); + } + public static Temporal? FromHexWKB(string hexwkb) => MEOSFactory.WrapTemporal(Meos.TemporalFromHexwkb(hexwkb)); @@ -603,6 +614,17 @@ public bool UpperInc() } } + public static Temporal? MergeAgg(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalMergeTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + public static Temporal? MergeArray(Temporal[] temparr) { IntPtr[] _temparrValues = new IntPtr[temparr.Length]; @@ -622,5 +644,82 @@ public bool UpperInc() } } + public static Temporal? ReachabilityFilterAgg(Temporal[] values, double maxspeed) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalReachabilityFilterTransfn(_state, _v.Ptr, maxspeed); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalReachabilityFilterFinalfn(_state)); + } + + public static Temporal? TAndAgg(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TboolTandTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TAvg(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TnumberTavgTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TnumberTavgFinalfn(_state)); + } + + public static Temporal? TCount(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TemporalTcountTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? TOrAgg(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TboolTorTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? Tdensity(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TpcpatchTdensityTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + + public static Temporal? Tnpoints(Temporal[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TpcpatchTnpointsTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapTemporal(Meos.TemporalTaggFinalfn(_state)); + } + } } diff --git a/MEOS.NET/Types/Text.g.cs b/MEOS.NET/Types/Text.g.cs index 0017088..14c7ecb 100644 --- a/MEOS.NET/Types/Text.g.cs +++ b/MEOS.NET/Types/Text.g.cs @@ -129,5 +129,16 @@ public bool Right(TextSet s) public static Text? FromCstring(string str) => MEOSFactory.WrapText(Meos.CstringToText(str)); + public static Set? SetUnionAgg(Text[] values) + { + IntPtr _state = IntPtr.Zero; + foreach (var _v in values) + { + _state = Meos.TextUnionTransfn(_state, _v.Ptr); + } + + return MEOSFactory.WrapSet(Meos.SetUnionFinalfn(_state)); + } + } } diff --git a/tools/objectgen.py b/tools/objectgen.py index cd6ea64..5ec60e0 100644 --- a/tools/objectgen.py +++ b/tools/objectgen.py @@ -63,6 +63,15 @@ "ancestor, a second function for one call, or would take the calls of " "an ancestor's member the layer does not emit and so cannot declare " "again beside it.", + "aggregate served by several transitions": + "Several transition functions serve one aggregate name over values of " + "the class, and nothing in the values tells them apart.", + "aggregate state not threadable": + "The transition and the final function of the aggregate do not pass " + "one state pointer from call to call.", + "aggregate argument or result needs marshalling": + "An argument of the transition or the result of the final function has " + "no rule of this generator.", } GENERATOR_VERSION = "0.1.0" @@ -414,6 +423,9 @@ def __init__(self, name: str, ret: str, params: list[tuple[str, str]], # (parameter name, struct) for each array of structs of scalars and # strings the method lays out for MEOS (#written_struct). self.written: list[tuple[str, str]] = [] + # The whole body, braces included, of a method no call template + # spells, as an aggregate threads its transition over the values. + self.lines: list[str] | None = None def needs_a_body(self) -> bool: """Whether the call needs anything allocated, pinned or read around it.""" @@ -1352,6 +1364,90 @@ def inherited_names(self, cls: str) -> set[tuple]: p = self.m.parent.get(p) return names + def aggregate_methods(self, cls: str) -> list[Method]: + """The aggregates over the values of a class, one static method each. + + Built beside #method_for, whose #map_param and #map_return it calls for + the transition's arguments and the final function's result, as + #aggregateMethods of MEOS.js's codegen/ObjectGenerator.ts builds them: + the catalog's `aggregates` whose transition takes the class's C type + after its state, named as an engine holding one function per name calls + them, the aggregate's `altSqlName` or else its `sqlName`, as MobilityDuck + registers one. The method threads the transition over the values from a + NULL state, as MEOS's C callers do, and answers the final function's + result; the final function frees the state. An aggregate two transitions + serve under one name over this class has no method of its own: its + overloads take the same values and nothing tells them apart.""" + by_name: dict[str, list[tuple[str, str]]] = {} + for agg in self.m.idl.get("aggregates") or []: + transition = (agg.get("transition") or {}).get("meos") + final = (agg.get("final") or {}).get("meos") + f = transition and self.m.functions.get(transition) + if not f or not final or len(f.get("params", [])) < 2: + continue + if self.m.class_for_ctype(clean(f["params"][1]["canonical"])) != cls: + continue + name = agg.get("altSqlName") or agg["sqlName"] + seen = by_name.setdefault(name, []) + if (transition, final) not in seen: + seen.append((transition, final)) + methods = [] + for name, overloads in by_name.items(): + if len({t for t, _f in overloads}) > 1: + self.defer(cls, name, "aggregate served by several transitions", + ", ".join(t for t, _f in overloads)) + continue + transition, final = overloads[0] + tsig = codegen.SIGNATURES.get(transition) + fsig = codegen.SIGNATURES.get(final) + ff = self.m.functions.get(final) + if (not tsig or not fsig or not ff or tsig[0] != "IntPtr" + or len(tsig[1]) < 2 or tsig[1][0][0] != "IntPtr" + or len(fsig[1]) != 1): + self.defer(cls, name, "aggregate state not threadable", + f"{transition} and {final} do not pass one state pointer") + continue + f = self.m.functions[transition] + c_by_name = { + (codegen.csharp_param_name(p["name"]) if p["name"] else "arg"): p + for p in f.get("params", []) + } + mapped = [] + for i, (cs_type, pname) in enumerate(tsig[1][1:]): + p = c_by_name.get(pname, {}) + arg = "_v" if i == 0 else ident(pname) + m = self.map_param(p.get("canonical", cs_type), cs_type, arg, + self.m.class_for_value(p) if p else None) + if m is None or m[1] == scratch(arg): + mapped = None + break + mapped.append((m, pname)) + ret = self.map_return(ff, fsig[0]) if mapped else None + if not mapped or ret is None: + self.defer(cls, name, "aggregate argument or result needs marshalling", + f"{transition} / {final}") + continue + (item_type, item_arg), _ = mapped[0] + params = [(f"{item_type}[]", "values")] + [ + (t, pname) for (t, _a), pname in mapped[1:]] + args = ", ".join(["_state", item_arg] + [a for (_t, a), _p in mapped[1:]]) + call = f"Meos.{codegen.public_name(transition)}({args})" + answer = ret[1].replace("$", f"Meos.{codegen.public_name(final)}(_state)") + method = Method(pascal(name), ret[0], params, answer, True) + method.lines = [ + " {", + " IntPtr _state = IntPtr.Zero;", + " foreach (var _v in values)", + " {", + f" _state = {call};", + " }", + "", + f" return {answer};", + " }", + ] + methods.append(method) + return methods + def emit_class(self, cls: str) -> str: parent = self.m.parent.get(cls) or "MEOSObject" entries = [e for e in self.m.om["classes"].get(cls, {}).get("methods", []) @@ -1359,6 +1455,14 @@ def emit_class(self, cls: str) -> str: paired = [(e["function"], self.method_for(cls, e)) for e in entries] paired = self.take_portable_names(cls, paired, entries) methods = [m for _f, m in paired if m] + inherited_names = self.inherited_names(cls) + for m in self.aggregate_methods(cls): + if any(o.name == m.name for o in methods) or any( + name == m.name for name, _t in inherited_names): + self.defer(cls, m.name, "signature taken by a method", + "an aggregate takes the name of a method") + continue + methods.append(m) methods.sort(key=lambda m: (m.static, m.name)) self.emitted += len(methods) # The C function behind each instance method this class or an ancestor @@ -1411,7 +1515,9 @@ def emit_class(self, cls: str) -> str: new = "new " if (m.name, tuple(t for t, _ in m.params)) in inherited else "" kind = "static " if m.static else "" lines.append(f" public {new}{kind}{m.ret} {m.name}({args})") - if m.needs_a_body(): + if m.lines is not None: + lines.extend(m.lines) + elif m.needs_a_body(): lines.extend(self.call_body(m)) else: lines.append(f" => {m.body};")