@as-pect/transform 8.0.1 → 9.0.0

package/README.md

@@ -1,11 +1,62 @@
-# `transform`
+# `@as-pect/transform`
 
-> TODO: description
+AssemblyScript transform for `as-pect` reflection support.
 
-## Usage
+This package implements the Class reflection transform. It injects the generated class reflection shape that the runtime helpers in `@as-pect/assembly` depend on when tests compare class instances or print reflected object values.
 
-```
-const transform = require('transform');
+## Generated shape
 
-// TODO: DEMONSTRATE API
-```
+For each class declaration found in source files and namespaces, the transform appends two public instance methods:
+
+- `__aspectStrictEquals(rawRef: Object, stack: usize[], cache: usize[], ignore: StaticArray<i64>): bool`
+- `__aspectAddReflectedValueKeyValuePairs(reflectedValue: i32, seen: Map<usize, i32>, ignore: StaticArray<i64>): void`
+
+These method names are compatibility-sensitive. `packages/assembly/assembly/internal/Reflect.ts` calls them directly when it cannot use a built-in comparison or reflected-value path.
+
+## ClassReflectionTransform
+
+`ClassReflectionTransform` is the module that owns the shared Class-member plan for generated class reflection behavior. It inspects each class once and records the instance members that should participate in both strict equality and reflected key/value generation.
+
+The member plan includes, in source order:
+
+- instance fields
+- instance getters
+
+The member plan excludes:
+
+- static members
+- regular instance methods
+- inherited members, which are handled by generated `super` calls
+
+Each planned member carries its name, source range, getter/field kind, and `djb2` name hash. Generated methods pass these hashes through `ignore: StaticArray<i64>` when calling `super` so inherited generated methods do not duplicate members overridden by a child class.
+
+Hash values intentionally remain the compatibility seam with existing generated code. If two inherited member names ever collide under `djb2`, the generated ignore list treats them as the same inherited member and suppresses the parent entry deterministically; the transform does not rename members or attempt a runtime fallback.
+
+## Generation responsibilities
+
+Class reflection generation is split across a few narrow responsibilities:
+
+- `index.ts` walks parsed sources and namespaces, then delegates class and interface declarations to the generation module.
+- `appendGeneratedClassReflectionMembers.ts` orchestrates which generated members or interface contracts should be appended, including idempotence checks and user-authored collision errors.
+- `ClassReflectionTransform.ts` owns compatibility-sensitive generated member names, generated-member marking, class/interface collision checks, local equality-operator detection, and the Class-member plan.
+- `createStrictEqualsMember.ts`, `createAddReflectedValueKeyValuePairsMember.ts`, and `createInterfaceReflectionMembers.ts` build the generated AssemblyScript AST for each runtime method shape.
+
+This keeps traversal, planning, collision policy, and AST construction separate enough that a change to one generated method does not require re-learning every transform rule.
+
+## Runtime relationship
+
+`@as-pect/assembly` uses the generated methods in two places:
+
+1. `Reflect.equals()` calls `__aspectStrictEquals` to compare class instances structurally.
+2. `Reflect.toReflectedValue()` calls `__aspectAddReflectedValueKeyValuePairs` to add reflected object keys and values.
+
+The transform and runtime therefore share a seam: the transform owns the generated method shape, and the runtime assumes that shape exists after compilation with `@as-pect/transform`.
+
+## Compatibility expectations
+
+- Keep both generated method names unchanged unless a coordinated runtime migration is planned.
+- Keep the `ignore` hash behavior stable so inherited and overridden members are not reported twice.
+- Keep generated behavior dependency-free; this package should remain a small local transform.
+- Preserve source order when adding reflected/equality-relevant members so reporter output remains stable.
+- Keep transform generation idempotent for the same parsed source; repeated passes should not append duplicate generated members.
+- Reject user-authored `__aspectStrictEquals` or `__aspectAddReflectedValueKeyValuePairs` members with a clear transform error instead of silently overwriting them.

package/lib/ClassReflectionTransform.js

@@ -0,0 +1,134 @@
+import { djb2Hash } from "./hash.js";
+/** The generated method runtime reflection calls for structural equality. */
+export const STRICT_EQUALS_MEMBER_NAME = "__aspectStrictEquals";
+/** The generated method runtime reflection calls to enumerate reflected object members. */
+export const ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME = "__aspectAddReflectedValueKeyValuePairs";
+/** The generated marker inherited by classes that should defer strict equality to @operator("=="). */
+export const HAS_EQ_OPERATOR_MEMBER_NAME = "__aspectHasEqOperator";
+const generatedClassReflectionMembers = new WeakSet();
+/** Mark a method declaration as generated by this transform pass. */
+export function markGeneratedClassReflectionMember(methodDeclaration) {
+    generatedClassReflectionMembers.add(methodDeclaration);
+    return methodDeclaration;
+}
+/**
+ * Decide whether a generated class reflection member can be appended.
+ *
+ * The same parsed source can be passed through the transform more than once by
+ * tests, tooling, or recovery flows. Members that were generated by this module
+ * are skipped on later passes; user-authored collisions are rejected so runtime
+ * reflection does not silently call a method with an incompatible signature.
+ */
+export function shouldGenerateClassReflectionMember(classDeclaration, memberName) {
+    return shouldGenerateReflectionMember(classDeclaration, "class", memberName);
+}
+/** Decide whether a generated interface reflection contract can be appended. */
+export function shouldGenerateInterfaceReflectionMember(interfaceDeclaration, memberName) {
+    return shouldGenerateReflectionMember(interfaceDeclaration, "interface", memberName);
+}
+function shouldGenerateReflectionMember(declaration, declarationKind, memberName) {
+    const existingMember = findMethod(declaration, memberName);
+    if (!existingMember)
+        return true;
+    if (generatedClassReflectionMembers.has(existingMember))
+        return false;
+    throw new Error(`Cannot generate ${memberName} for ${declarationKind} ${declaration.name.text} because that member already exists.`);
+}
+function findMethod(declaration, memberName) {
+    for (const member of declaration.members) {
+        if (member.kind !== 59 /* NodeKind.MethodDeclaration */)
+            continue;
+        const methodDeclaration = member;
+        if (methodDeclaration.name.text === memberName)
+            return methodDeclaration;
+    }
+    return null;
+}
+/** The kind of class member included in the class reflection member plan. */
+export var ClassReflectionMemberKind;
+(function (ClassReflectionMemberKind) {
+    ClassReflectionMemberKind["Field"] = "field";
+    ClassReflectionMemberKind["Getter"] = "getter";
+})(ClassReflectionMemberKind || (ClassReflectionMemberKind = {}));
+/** Return true when the class declares a local AssemblyScript equality operator overload. */
+export function hasLocalEqualsOperator(classDeclaration) {
+    for (const member of classDeclaration.members) {
+        if (member.kind !== 59 /* NodeKind.MethodDeclaration */)
+            continue;
+        const methodDeclaration = member;
+        if (!methodDeclaration.decorators)
+            continue;
+        for (const decorator of methodDeclaration.decorators) {
+            if (!decorator.args || decorator.args.length === 0)
+                continue;
+            if (!isOperatorDecoratorName(decorator.name))
+                continue;
+            const operatorName = decorator.args[0];
+            if (!operatorName)
+                continue;
+            if (operatorName.kind !== 17 /* NodeKind.Literal */)
+                continue;
+            if (operatorName.literalKind !== 2 /* LiteralKind.String */)
+                continue;
+            if (operatorName.value === "==")
+                return true;
+        }
+    }
+    return false;
+}
+function isOperatorDecoratorName(name) {
+    if (name.kind === 7 /* NodeKind.Identifier */)
+        return name.text === "operator";
+    if (name.kind === 22 /* NodeKind.PropertyAccess */) {
+        const propertyAccess = name;
+        return propertyAccess.expression.kind === 7 /* NodeKind.Identifier */ && propertyAccess.expression.text === "operator";
+    }
+    return false;
+}
+/**
+ * Create the shared member plan for class reflection generation.
+ *
+ * Instance fields and instance getters are included. Other methods, static
+ * members, and inherited members are intentionally left out; generated super
+ * calls handle inherited members while passing these hashes as the ignore list.
+ *
+ * @param classDeclaration - The class declaration to inspect.
+ */
+export function createClassReflectionMemberPlan(classDeclaration) {
+    const members = new Array();
+    for (const member of classDeclaration.members) {
+        if (!member.is(262144 /* CommonFlags.Instance */))
+            continue;
+        switch (member.kind) {
+            case 55 /* NodeKind.FieldDeclaration */: {
+                const fieldDeclaration = member;
+                const name = fieldDeclaration.name.text;
+                members.push({
+                    name,
+                    hash: djb2Hash(name),
+                    range: fieldDeclaration.range,
+                    kind: ClassReflectionMemberKind.Field,
+                });
+                break;
+            }
+            case 59 /* NodeKind.MethodDeclaration */: {
+                if (!member.is(2048 /* CommonFlags.Get */))
+                    break;
+                const methodDeclaration = member;
+                const name = methodDeclaration.name.text;
+                members.push({
+                    name,
+                    hash: djb2Hash(name),
+                    range: methodDeclaration.name.range,
+                    kind: ClassReflectionMemberKind.Getter,
+                });
+                break;
+            }
+        }
+    }
+    return {
+        classDeclaration,
+        members,
+        hashes: members.map((member) => member.hash),
+    };
+}

package/lib/appendGeneratedClassReflectionMembers.js

@@ -0,0 +1,30 @@
+import { ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, HAS_EQ_OPERATOR_MEMBER_NAME, STRICT_EQUALS_MEMBER_NAME, hasLocalEqualsOperator, markGeneratedClassReflectionMember, shouldGenerateClassReflectionMember, shouldGenerateInterfaceReflectionMember, } from "./ClassReflectionTransform.js";
+import { createAddReflectedValueKeyValuePairsMember } from "./createAddReflectedValueKeyValuePairsMember.js";
+import { createInterfaceAddReflectedValueKeyValuePairsMember, createInterfaceStrictEqualsMember, } from "./createInterfaceReflectionMembers.js";
+import { createHasEqualsOperatorMember, createStrictEqualsMember } from "./createStrictEqualsMember.js";
+/** Append all generated reflection members for a class declaration. */
+export function appendGeneratedClassReflectionMembers(classDeclaration) {
+    const shouldGenerateStrictEquals = shouldGenerateClassReflectionMember(classDeclaration, STRICT_EQUALS_MEMBER_NAME);
+    const shouldGenerateReflectedPairs = shouldGenerateClassReflectionMember(classDeclaration, ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME);
+    const shouldGenerateEqualsMarker = shouldGenerateClassReflectionMember(classDeclaration, HAS_EQ_OPERATOR_MEMBER_NAME);
+    if (hasLocalEqualsOperator(classDeclaration) && shouldGenerateEqualsMarker) {
+        classDeclaration.members.push(markGeneratedClassReflectionMember(createHasEqualsOperatorMember(classDeclaration)));
+    }
+    if (shouldGenerateStrictEquals) {
+        classDeclaration.members.push(markGeneratedClassReflectionMember(createStrictEqualsMember(classDeclaration)));
+    }
+    if (shouldGenerateReflectedPairs) {
+        classDeclaration.members.push(markGeneratedClassReflectionMember(createAddReflectedValueKeyValuePairsMember(classDeclaration)));
+    }
+}
+/** Append all generated reflection contracts for an interface declaration. */
+export function appendGeneratedInterfaceReflectionMembers(interfaceDeclaration) {
+    const shouldGenerateStrictEquals = shouldGenerateInterfaceReflectionMember(interfaceDeclaration, STRICT_EQUALS_MEMBER_NAME);
+    const shouldGenerateReflectedPairs = shouldGenerateInterfaceReflectionMember(interfaceDeclaration, ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME);
+    if (shouldGenerateStrictEquals) {
+        interfaceDeclaration.members.push(markGeneratedClassReflectionMember(createInterfaceStrictEqualsMember(interfaceDeclaration)));
+    }
+    if (shouldGenerateReflectedPairs) {
+        interfaceDeclaration.members.push(markGeneratedClassReflectionMember(createInterfaceAddReflectedValueKeyValuePairsMember(interfaceDeclaration)));
+    }
+}

package/lib/astHelpers.js

@@ -0,0 +1,21 @@
+import { TypeNode } from "assemblyscript/dist/assemblyscript.js";
+/** Create a named type without type arguments. */
+export function createSimpleNamedType(name, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range);
+}
+/** Create an Array<T> type for generated reflection members. */
+export function createArrayType(elementName, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName("Array", range), [createSimpleNamedType(elementName, range)], false, range);
+}
+/** Create a StaticArray<T> type for generated reflection members. */
+export function createStaticArrayType(elementName, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [createSimpleNamedType(elementName, range)], false, range);
+}
+/** Create a Map<K, V> type for generated reflection members. */
+export function createMapType(keyName, valueName, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName("Map", range), [createSimpleNamedType(keyName, range), createSimpleNamedType(valueName, range)], false, range);
+}
+/** Create a default parameter with the generated member range. */
+export function createDefaultParameter(name, type, range) {
+    return TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression(name, range), type, null, range);
+}

package/lib/createAddReflectedValueKeyValuePairsMember.js

@@ -1,176 +1,148 @@
-// import { } from "@as-pect/;
-import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
-import { createGenericTypeParameter } from "./createGenericTypeParameter.js";
-import { djb2Hash } from "./hash.js";
-// const TypeNode = TypeNode;
-// const {
-//   BlockStatement,
-//   ClassDeclaration,
-//   FieldDeclaration,
-//   MethodDeclaration,
-//   Range,
-//   Statement
-// } =
-// type BlockStatement = InstanceType<typeof BlockStatement>;
-// type ClassDeclaration = InstanceType<typeof ClassDeclaration>;
-// type FieldDeclaration = InstanceType<typeof FieldDeclaration>;
-// type MethodDeclaration = InstanceType<typeof MethodDeclaration>;
-// type Range = InstanceType<typeof Range>;
-// type Statement = InstanceType<typeof Statement>;
-/**
- * Create a prototype method called __aspectAddReflectedValueKeyValuePairs on a given
- * ClassDeclaration dynamically.
- *
- * @param {ClassDeclaration} classDeclaration - The target classDeclaration
- */
-export function createAddReflectedValueKeyValuePairsMember(classDeclaration) {
-    const range = classDeclaration.name.range;
-    // __aspectAddReflectedValueKeyValuePairs(reflectedValue: i32, seen: Map<usize, i32>, ignore: StaticArray<i64>): void
-    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression("__aspectAddReflectedValueKeyValuePairs", range), null, 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([
-        // reflectedValue: i32
-        TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression("reflectedValue", range), createGenericTypeParameter("i32", range), null, range),
-        // seen: Map<usize, i32>
-        TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression("seen", range), TypeNode.createNamedType(TypeNode.createSimpleTypeName("Map", range), [createGenericTypeParameter("usize", range), createGenericTypeParameter("i32", range)], false, range), null, range),
-        // ignore: i64[]
-        TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression("ignore", range), 
-        // Array<i64> -> i64[]
-        TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [createGenericTypeParameter("i64", range)], false, range), null, range),
-    ], 
-    // : void
-    TypeNode.createNamedType(TypeNode.createSimpleTypeName("void", range), [], false, range), null, false, range), createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration), range);
-}
-/**
- * Iterate over a given ClassDeclaration and return a block statement that contains the
- * body of a supposed function that reports the key value pairs of a given class.
- *
- * @param {ClassDeclaration} classDeclaration - The class declaration to be reported
- */
-function createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration) {
-    const body = new Array();
-    const range = classDeclaration.name.range;
-    const nameHashes = new Array();
-    // for each field declaration, generate a check
-    for (const member of classDeclaration.members) {
-        // if it's an instance member, regardless of access modifier
-        if (member.is(262144 /* CommonFlags.Instance */)) {
-            switch (member.kind) {
-                // field declarations automatically get added
-                case 54 /* NodeKind.FieldDeclaration */: {
-                    const fieldDeclaration = member;
-                    const hashValue = djb2Hash(member.name.text);
-                    pushKeyValueIfStatement(body, member.name.text, hashValue, fieldDeclaration.range);
-                    nameHashes.push(hashValue);
-                    break;
-                }
-                // function declarations can be getters, check the get flag
-                case 58 /* NodeKind.MethodDeclaration */: {
-                    if (member.is(2048 /* CommonFlags.Get */)) {
-                        const methodDeclaration = member;
-                        const hashValue = djb2Hash(member.name.text);
-                        pushKeyValueIfStatement(body, member.name.text, hashValue, methodDeclaration.range);
-                        nameHashes.push(hashValue);
-                    }
-                    break;
-                }
-            }
-        }
-    }
-    // call into super first after all the property checks have been added
-    body.unshift(createIsDefinedIfStatement(nameHashes, range));
-    return TypeNode.createBlockStatement(body, range);
-}
-/**
- * Create an isDefined() function call with an if statement to prevent calls to
- * super where they should not be made.
- *
- * @param {number[]} nameHashes - The array of property names to ignore in the children
- * @param {Range} range - The reporting range of this statement
- */
-function createIsDefinedIfStatement(nameHashes, range) {
-    // if (isDefined(super.__aspectAddReflectedValueKeyValuePairs))
-    //   super.__aspectAddReflectedValueKeyValuePairs(reflectedValue, seen, StaticArray.concat(ignore, [...] as StaticArray<i64>))
-    return TypeNode.createIfStatement(
-    // isDefined(super.__aspectAddReflectedValueKeyValuePairs)
-    TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
-        // super.__aspectAddReflectedValueKeyValuePairs
-        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectAddReflectedValueKeyValuePairs", range), range),
-    ], range), TypeNode.createBlockStatement([
-        TypeNode.createExpressionStatement(
-        // super.__aspectAddReflectedValueKeyValuePairs(reflectedValue, seen, StaticArray.concat(ignore, [...] as StaticArray<i64>))
-        TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectAddReflectedValueKeyValuePairs", range), range), null, [
-            // reflectedValue,
-            TypeNode.createIdentifierExpression("reflectedValue", range),
-            // seen,
-            TypeNode.createIdentifierExpression("seen", range),
-            // StaticArray.concat(ignore, [...])
-            TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("StaticArray", range), TypeNode.createIdentifierExpression("concat", range), range), null, [
-                TypeNode.createIdentifierExpression("ignore", range),
-                // [...propNames]
-                TypeNode.createAssertionExpression(1 /* AssertionKind.As */, TypeNode.createArrayLiteralExpression(nameHashes.map((e) => TypeNode.createIntegerLiteralExpression(f64_as_i64(e), range)), range), TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName("i64", range), null, false, range)], false, range), range),
-            ], range),
-        ], range)),
-    ], range), null, range);
-}
-/**
- * For each key-value pair, we need to perform a runtime check to make sure that this property
- * was not overridden in the parent of a given class.
- *
- * @param {Statement[]} body - The collection of statements for the function body
- * @param {string} name - The name of the property
- * @param {Range} range - The range for these statements
- */
-function pushKeyValueIfStatement(body, name, hashValue, range) {
-    body.push(
-    // if (!ignore.includes("propName")) { ... }
-    TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, 
-    // ignore.includes("propName")
-    TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("ignore", range), TypeNode.createIdentifierExpression("includes", range), range), null, [
-        // hashValue
-        TypeNode.createIntegerLiteralExpression(f64_as_i64(hashValue), range),
-    ], range), range), TypeNode.createBlockStatement([createPushReflectedObjectKeyStatement(name, range), createPushReflectedObjectValueStatement(name, range)], range), null, range));
-}
-/**
- * Create a function call to __aspectPushReflectedObjectKey to add a key to a given
- * reflected value.
- *
- * @param {string} name - The name of the property
- * @param {Range} range - The reange for this function call
- */
-function createPushReflectedObjectKeyStatement(name, range) {
-    // __aspectPushReflectedObjectKey(reflectedValue, Reflect.toReflectedValue("propertyName", seen));
-    return TypeNode.createExpressionStatement(TypeNode.createCallExpression(TypeNode.createIdentifierExpression("__aspectPushReflectedObjectKey", range), null, [
-        // reflectedValue
-        TypeNode.createIdentifierExpression("reflectedValue", range),
-        // Reflect.toReflectedValue("propertyName", seen)
-        TypeNode.createCallExpression(
-        // Reflect.toReflectedValue
-        TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("Reflect", range), TypeNode.createIdentifierExpression("toReflectedValue", range), range), null, [TypeNode.createStringLiteralExpression(name, range), TypeNode.createIdentifierExpression("seen", range)], range),
-    ], range));
-}
-/**
- * Create a function call to __aspectPushReflectedObjectValue to add a key to a given
- * reflected value.
- *
- * @param {string} name - The name of the property
- * @param {Range} range - The reange for this function call
- */
-function createPushReflectedObjectValueStatement(name, range) {
-    // __aspectPushReflectedObjectValue(reflectedValue, Reflect.toReflectedValue(this.propertyName, seen, ignore.concat([...])));
-    return TypeNode.createExpressionStatement(
-    // __aspectPushReflectedObjectValue(reflectedValue, Reflect.toReflectedValue(this.propertyName, seen, ignore.concat([...])))
-    TypeNode.createCallExpression(
-    // __aspectPushReflectedObjectValue
-    TypeNode.createIdentifierExpression("__aspectPushReflectedObjectValue", range), null, [
-        // reflectedValue
-        TypeNode.createIdentifierExpression("reflectedValue", range),
-        // Reflect.toReflectedValue(this.propertyName, seen))
-        TypeNode.createCallExpression(
-        // Reflect.toReflectedValue
-        TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("Reflect", range), TypeNode.createIdentifierExpression("toReflectedValue", range), range), null, [
-            //this.propertyName
-            TypeNode.createPropertyAccessExpression(TypeNode.createThisExpression(range), TypeNode.createIdentifierExpression(name, range), range),
-            // seen
-            TypeNode.createIdentifierExpression("seen", range),
-        ], range),
-    ], range));
-}
+import { ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, createClassReflectionMemberPlan, } from "./ClassReflectionTransform.js";
+import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
+import { createDefaultParameter, createMapType, createSimpleNamedType, createStaticArrayType } from "./astHelpers.js";
+import { createInheritedIgnoreListExpression } from "./createInheritedIgnoreListExpression.js";
+// const TypeNode = TypeNode;
+// const {
+//   BlockStatement,
+//   ClassDeclaration,
+//   FieldDeclaration,
+//   MethodDeclaration,
+//   Range,
+//   Statement
+// } =
+// type BlockStatement = InstanceType<typeof BlockStatement>;
+// type ClassDeclaration = InstanceType<typeof ClassDeclaration>;
+// type FieldDeclaration = InstanceType<typeof FieldDeclaration>;
+// type MethodDeclaration = InstanceType<typeof MethodDeclaration>;
+// type Range = InstanceType<typeof Range>;
+// type Statement = InstanceType<typeof Statement>;
+/**
+ * Create a prototype method called __aspectAddReflectedValueKeyValuePairs on a given
+ * ClassDeclaration dynamically.
+ *
+ * @param {ClassDeclaration} classDeclaration - The target classDeclaration
+ */
+export function createAddReflectedValueKeyValuePairsMember(classDeclaration) {
+    const range = classDeclaration.name.range;
+    // __aspectAddReflectedValueKeyValuePairs(reflectedValue: i32, seen: Map<usize, i32>, ignore: StaticArray<i64>): void
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression(ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, range), null, 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([
+        // reflectedValue: i32
+        createDefaultParameter("reflectedValue", createSimpleNamedType("i32", range), range),
+        // seen: Map<usize, i32>
+        createDefaultParameter("seen", createMapType("usize", "i32", range), range),
+        // ignore: i64[]
+        createDefaultParameter("ignore", createStaticArrayType("i64", range), range),
+    ], 
+    // : void
+    createSimpleNamedType("void", range), null, false, range), createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration), range);
+}
+/**
+ * Iterate over a given ClassDeclaration and return a block statement that contains the
+ * body of a supposed function that reports the key value pairs of a given class.
+ *
+ * @param {ClassDeclaration} classDeclaration - The class declaration to be reported
+ */
+function createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration) {
+    const body = new Array();
+    const range = classDeclaration.name.range;
+    const memberPlan = createClassReflectionMemberPlan(classDeclaration);
+    // Add key/value reflection for each reflected/equality-relevant class member.
+    for (const member of memberPlan.members) {
+        pushKeyValueIfStatement(body, member.name, member.hash, member.range);
+    }
+    // call into super first after all the property checks have been added
+    body.unshift(createIsDefinedIfStatement(memberPlan.hashes, range));
+    return TypeNode.createBlockStatement(body, range);
+}
+/**
+ * Create an isDefined() function call with an if statement to prevent calls to
+ * super where they should not be made.
+ *
+ * @param {number[]} nameHashes - The array of property names to ignore in the children
+ * @param {Range} range - The reporting range of this statement
+ */
+function createIsDefinedIfStatement(nameHashes, range) {
+    // if (isDefined(super.__aspectAddReflectedValueKeyValuePairs))
+    //   super.__aspectAddReflectedValueKeyValuePairs(reflectedValue, seen, StaticArray.concat(ignore, [...] as StaticArray<i64>))
+    return TypeNode.createIfStatement(
+    // isDefined(super.__aspectAddReflectedValueKeyValuePairs)
+    TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
+        // super.__aspectAddReflectedValueKeyValuePairs
+        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression(ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, range), range),
+    ], range), TypeNode.createBlockStatement([
+        TypeNode.createExpressionStatement(
+        // super.__aspectAddReflectedValueKeyValuePairs(reflectedValue, seen, StaticArray.concat(ignore, [...] as StaticArray<i64>))
+        TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression(ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, range), range), null, [
+            // reflectedValue,
+            TypeNode.createIdentifierExpression("reflectedValue", range),
+            // seen,
+            TypeNode.createIdentifierExpression("seen", range),
+            // StaticArray.concat(ignore, [...])
+            createInheritedIgnoreListExpression(nameHashes, range),
+        ], range)),
+    ], range), null, range);
+}
+/**
+ * For each key-value pair, we need to perform a runtime check to make sure that this property
+ * was not overridden in the parent of a given class.
+ *
+ * @param {Statement[]} body - The collection of statements for the function body
+ * @param {string} name - The name of the property
+ * @param {Range} range - The range for these statements
+ */
+function pushKeyValueIfStatement(body, name, hashValue, range) {
+    body.push(
+    // if (!ignore.includes("propName")) { ... }
+    TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, 
+    // ignore.includes("propName")
+    TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("ignore", range), TypeNode.createIdentifierExpression("includes", range), range), null, [
+        // hashValue
+        TypeNode.createIntegerLiteralExpression(f64_as_i64(hashValue), range),
+    ], range), range), TypeNode.createBlockStatement([createPushReflectedObjectKeyStatement(name, range), createPushReflectedObjectValueStatement(name, range)], range), null, range));
+}
+/**
+ * Create a function call to __aspectPushReflectedObjectKey to add a key to a given
+ * reflected value.
+ *
+ * @param {string} name - The name of the property
+ * @param {Range} range - The reange for this function call
+ */
+function createPushReflectedObjectKeyStatement(name, range) {
+    // __aspectPushReflectedObjectKey(reflectedValue, Reflect.toReflectedValue("propertyName", seen));
+    return TypeNode.createExpressionStatement(TypeNode.createCallExpression(TypeNode.createIdentifierExpression("__aspectPushReflectedObjectKey", range), null, [
+        // reflectedValue
+        TypeNode.createIdentifierExpression("reflectedValue", range),
+        // Reflect.toReflectedValue("propertyName", seen)
+        TypeNode.createCallExpression(
+        // Reflect.toReflectedValue
+        TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("Reflect", range), TypeNode.createIdentifierExpression("toReflectedValue", range), range), null, [TypeNode.createStringLiteralExpression(name, range), TypeNode.createIdentifierExpression("seen", range)], range),
+    ], range));
+}
+/**
+ * Create a function call to __aspectPushReflectedObjectValue to add a key to a given
+ * reflected value.
+ *
+ * @param {string} name - The name of the property
+ * @param {Range} range - The reange for this function call
+ */
+function createPushReflectedObjectValueStatement(name, range) {
+    // __aspectPushReflectedObjectValue(reflectedValue, Reflect.toReflectedValue(this.propertyName, seen, ignore.concat([...])));
+    return TypeNode.createExpressionStatement(
+    // __aspectPushReflectedObjectValue(reflectedValue, Reflect.toReflectedValue(this.propertyName, seen, ignore.concat([...])))
+    TypeNode.createCallExpression(
+    // __aspectPushReflectedObjectValue
+    TypeNode.createIdentifierExpression("__aspectPushReflectedObjectValue", range), null, [
+        // reflectedValue
+        TypeNode.createIdentifierExpression("reflectedValue", range),
+        // Reflect.toReflectedValue(this.propertyName, seen))
+        TypeNode.createCallExpression(
+        // Reflect.toReflectedValue
+        TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("Reflect", range), TypeNode.createIdentifierExpression("toReflectedValue", range), range), null, [
+            //this.propertyName
+            TypeNode.createPropertyAccessExpression(TypeNode.createThisExpression(range), TypeNode.createIdentifierExpression(name, range), range),
+            // seen
+            TypeNode.createIdentifierExpression("seen", range),
+        ], range),
+    ], range));
+}

package/lib/createGenericTypeParameter.js

@@ -1,10 +1,10 @@
-import { TypeNode } from "assemblyscript/dist/assemblyscript.js";
-/**
- * This method makes a generic named parameter.
- *
- * @param {string} name - The name of the type.
- * @param {Range} range - The range given for the type parameter.
- */
-export function createGenericTypeParameter(name, range) {
-    return TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range);
-}
+import { TypeNode } from "assemblyscript/dist/assemblyscript.js";
+/**
+ * This method makes a generic named parameter.
+ *
+ * @param {string} name - The name of the type.
+ * @param {Range} range - The range given for the type parameter.
+ */
+export function createGenericTypeParameter(name, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range);
+}

package/lib/createInheritedIgnoreListExpression.js

@@ -0,0 +1,11 @@
+import { TypeNode } from "assemblyscript/dist/assemblyscript.js";
+import { createStaticArrayType } from "./astHelpers.js";
+/**
+ * Create `StaticArray.concat(ignore, [...hashes] as StaticArray<i64>)` for inherited member suppression.
+ */
+export function createInheritedIgnoreListExpression(nameHashes, range) {
+    return TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("StaticArray", range), TypeNode.createIdentifierExpression("concat", range), range), null, [
+        TypeNode.createIdentifierExpression("ignore", range),
+        TypeNode.createAssertionExpression(1 /* AssertionKind.As */, TypeNode.createArrayLiteralExpression(nameHashes.map((hash) => TypeNode.createIntegerLiteralExpression(f64_as_i64(hash), range)), range), createStaticArrayType("i64", range), range),
+    ], range);
+}