[interop] Add Support for Anonymous Declarations #434

nikeokoronkwo · 2025-08-02T03:25:22Z

Fixes #385
Fixes #422
Fixes #410
Fixes #433

This PR adds support for generating declarations for anonymous declarations, such as anonymous objects, unions, closures and constructor types.

This PR also adds support for nullable types (types unioned with undefined and/or null).

A hashing function is used for consistently hashing string objects, which is used for hashing identifiers for anonymous unions, objects and more, as well as comparing such names to allow reusing of such types.

Anonymous Unions are turned into a Dart (anonymous) extension type which has a rep type/implements the shared type between the union parts. It has getters to get the value as a certain probability of the union. For instance, a union string | number | boolean may look like the following:
```
extension type _AnonymousUnion_204398._(JSAny _) implements JSAny {
  String get asString => (_ as JSString).toDart;
  double get asDouble => (_ as JSNumber).toDartDouble;
  bool get asBool => (_ as JSBoolean).toDart;
}
```

Anonymous Tuples are turned into an instance of a JSTupleX declaration generated depending on the number of members it may have (i.e if a 2 member tuple exists, it will be an instance of JSTuple2<A, B>). The tuple extension type looks like the following:

// normal
extension type JSTupleX<A, B, ..., B1>._(JSArray<JSAny> _) implements JSArray<JSAny> {
  A get $1 => _[0] as A;
  B get $2 => _[1] as B;
  /* ... */
  B1 get $x => _[x] as B1;
  
  set $1(A newValue) => _[0] = newValue;
  set $2(B newValue) => _[1] = newValue;
  /* ... */
  set $x(B1 newValue) => _[x] = newValue;
}

// readonly
extension type JSReadonlyTupleX<A, B, ..., B1>._(JSArray<JSAny> _) implements JSArray<JSAny> {
  A get $1 => _[0] as A;
  B get $2 => _[1] as B;
  /* ... */
  B1 get $x => _[x] as B1;
}

Anonymous Closures are turned into extension types implementing call. While Anonymous function types ((str: string) => void) have their call implementations as external, anonymous constructor types (new (str: string) => T to construct T) are implemented as function calls to create the given object. In the future after Make JSExportedDartFunction generic and add a toJSGeneric function sdk#54557, we should be able to replace this with a generic JSFunction.
```
extension type _AnonymousFunction_123456._(JSFunction _) implements JSFunction {
  external void call(String str);
}

// Assuming T is defined elsewhere and is **not** a generic
extension type _AnonymousFunction_123456._(JSFunction _) implements JSFunction {
  T call(String str) => T(str);
}
```
Anonymous Objects are implemented as extension type objects with their default constructor as an object literal constructor. They also inherit any associated generic types alongside.

web_generator/lib/src/ast/base.dart

web_generator/lib/src/ast/builtin.dart

web_generator/lib/src/ast/helpers.dart

web_generator/lib/src/ast/declarations.dart

srujzs · 2025-08-08T17:15:20Z

web_generator/test/integration/interop_gen/ts_typing_expected.dart

+@_i1.JS()
+external _AnonymousUnion_1189263 get responseObject;
+@_i1.JS()
+external _AnonymousConstructor_1059824 get productConstr;


Oh I may have miscommunicated earlier what I meant, but I was thinking of making these constructor values like

Product productConstr( num id, String name, num price, ) => Product( id: id.toDouble(), name: name, price: price.toDouble(), );

instead. I'm not really sure it's useful for users to have this constructor as a getter (and it avoids the extra anonymous extension type if we don't), but I'm also totally okay with going the current route if you feel like it's better.

The constructor call shouldn't be a getter, it should be an override on call, so it is intended to be called as productConstr().

I do not know the implications of having it as a variable vs as a function.

I feel the anonymous extensions are useful, as in this example, they can be extended/implemented and typealiased.

Do you have any thoughts concerning these?

web_generator/test/integration/interop_gen/ts_typing_input.d.ts

web_generator/test/type_map_test.dart

srujzs · 2025-08-08T17:26:59Z

web_generator/test/type_map_test.dart

+    });
+
+    test('Sub Type Interface Test', () {
+      final a = InterfaceDeclaration(


I'd consider a case where we check the LCA of three types where the pairwise LCAs are different than the LCA of all the types. This is to check we're not accidentally composing the LCAs (which we aren't).

e.g.

C -> B -> A E -> D -> B F -> H -> B E -> G -> A F -> G -> A

LCA{E, F} = G but LCA{C, E, F} (B) != LCA{C, LCA{E, F}} (A)

srujzs

Thanks, Nike! Just a couple more comments.

srujzs · 2025-08-11T23:07:00Z

web_generator/lib/src/ast/builtin.dart

-
-  @override
-  set isNullable(bool isNullable) {}
+  bool isNullable;


Can we not make this late and only set it when we have the value instead of defaulting like we do in line 32?

We can, but it isn't guaranteed to be set. It is only set if isNullable is set

/// isNullable can be null Type _transformType(TSTypeNode type, {bool parameter = false, bool typeArg = false, bool? isNullable}) { // code }

srujzs · 2025-08-11T23:07:34Z

web_generator/lib/src/ast/builtin.dart

@@ -51,7 +46,7 @@ class BuiltinType extends Type {
          .where((p) => typeParams.length != 1 || p != $voidType)
          .map((p) => p.emit(options)))
      ..url = fromDartJSInterop ? 'dart:js_interop' : null
-      ..isNullable = _isNullable ?? options?.nullable);
+      ..isNullable = isNullable || (options?.nullable ?? false));


In theory, isNullable should have been set so we should not see any late initialization errors with the propose change above.

srujzs · 2025-08-11T23:13:10Z

web_generator/lib/src/ast/helpers.dart

+      _ => BuiltinType.primitiveType(PrimitiveType.object, isNullable: false)
+    };
+  } else if (cl case InterfaceDeclaration(extendedTypes: [final extendee])) {
+    return switch (extendee) {


I guess the same question applies when cl (which should maybe be called td now :D) is a ClassDeclaration as well.

web_generator/lib/src/ast/helpers.dart

web_generator/lib/src/ast/types.dart

web_generator/lib/src/interop_gen/sub_type.dart

srujzs · 2025-08-11T23:31:46Z

web_generator/lib/src/interop_gen/sub_type.dart

+  final topoList = topologicalList(typeMaps.toList());
+  for (final level in topoList) {
+    final typesAtLevel = commonTypes.intersection(level);
+    if (typesAtLevel.isNotEmpty) {


I'd just briefly leave a comment here mentioning that by definition, another least common ancestor can't be in the next level.

Maybe I haven't hit a case, but I haven't encountered one so far. Is there an edge-case I'm missing?

srujzs · 2025-08-11T23:33:09Z

web_generator/lib/src/interop_gen/sub_type.dart

      return;
    }
-    nodes.add(TypeHierarchalTree(list.first)..addValues(list.skip(1)));
+    nodes.add(TypeHierarchy(list.first)..addChainedValues(list.skip(1)));
  }

  Set<String> expand() {


I'd cache in this method as we use the result of this for intersections.

Is there a good way of caching this and invalidating if nodes is modified?

nikeokoronkwo and others added 8 commits August 1, 2025 17:39

wip: union types

1c76d12

wip: completed anonymous unions

d79c2cf

implemented JS Tuple

38b3aab

completed nullability support for undefined and null

cb90943

Merge branch 'main' into interop/anonymous

37e0d1a

wip: object decl

0b943e7

implemented anonymous objects

e7535a4

added support for closures and constructors

c49ce6c

nikeokoronkwo marked this pull request as ready for review August 7, 2025 00:48

nikeokoronkwo added 2 commits August 6, 2025 20:48

wip: type hierarchy

f1a9e1c

implemented sub type deduction

7f0a2e0

nikeokoronkwo requested a review from srujzs August 7, 2025 05:39

nikeokoronkwo added 2 commits August 7, 2025 14:31

added type generics to union types

f57165c

changed .reduce to .fold

49aa015

srujzs reviewed Aug 8, 2025

View reviewed changes

nikeokoronkwo added 3 commits August 8, 2025 13:47

resolved newline and license headers

574250f

isNullable updates and renamed DeclarationAssociatedType

283ab5d

updated algorithm to use LCA via Topological Ordering

4a9bca6

srujzs approved these changes Aug 11, 2025

View reviewed changes

nikeokoronkwo added 2 commits August 11, 2025 20:18

resolved some more comments

78a535f

rm hasher_test

5421359

[interop] Add Support for Anonymous Declarations #434

Are you sure you want to change the base?

[interop] Add Support for Anonymous Declarations #434

Uh oh!

Conversation

nikeokoronkwo commented Aug 2, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

srujzs left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

nikeokoronkwo commented Aug 2, 2025 •

edited

Loading