@as-pect/transform 8.1.0 → 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,7 +1,7 @@
-// import { } from "@as-pect/;
+import { ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, createClassReflectionMemberPlan, } from "./ClassReflectionTransform.js";
 import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
-import { createGenericTypeParameter } from "./createGenericTypeParameter.js";
-import { djb2Hash } from "./hash.js";
+import { createDefaultParameter, createMapType, createSimpleNamedType, createStaticArrayType } from "./astHelpers.js";
+import { createInheritedIgnoreListExpression } from "./createInheritedIgnoreListExpression.js";
 // const TypeNode = TypeNode;
 // const {
 //   BlockStatement,
@@ -26,18 +26,16 @@ import { djb2Hash } from "./hash.js";
 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([
+    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
-        TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression("reflectedValue", range), createGenericTypeParameter("i32", range), null, range),
+        createDefaultParameter("reflectedValue", createSimpleNamedType("i32", range), 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),
+        createDefaultParameter("seen", createMapType("usize", "i32", range), 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),
+        createDefaultParameter("ignore", createStaticArrayType("i64", range), range),
     ], 
     // : void
-    TypeNode.createNamedType(TypeNode.createSimpleTypeName("void", range), [], false, range), null, false, range), createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration), range);
+    createSimpleNamedType("void", range), null, false, range), createAddReflectedValueKeyValuePairsFunctionBody(classDeclaration), range);
 }
 /**
  * Iterate over a given ClassDeclaration and return a block statement that contains the
@@ -48,35 +46,13 @@ export function createAddReflectedValueKeyValuePairsMember(classDeclaration) {
 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;
-                }
-            }
-        }
+    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(nameHashes, range));
+    body.unshift(createIsDefinedIfStatement(memberPlan.hashes, range));
     return TypeNode.createBlockStatement(body, range);
 }
 /**
@@ -93,21 +69,17 @@ function createIsDefinedIfStatement(nameHashes, range) {
     // isDefined(super.__aspectAddReflectedValueKeyValuePairs)
     TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
         // super.__aspectAddReflectedValueKeyValuePairs
-        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectAddReflectedValueKeyValuePairs", range), range),
+        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("__aspectAddReflectedValueKeyValuePairs", range), range), null, [
+        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, [...])
-            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),
+            createInheritedIgnoreListExpression(nameHashes, range),
         ], range)),
     ], range), null, 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);
+}

package/lib/createInterfaceReflectionMembers.js

@@ -0,0 +1,25 @@
+import { TypeNode } from "assemblyscript/dist/assemblyscript.js";
+import { ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, STRICT_EQUALS_MEMBER_NAME, } from "./ClassReflectionTransform.js";
+import { createArrayType, createDefaultParameter, createMapType, createSimpleNamedType, createStaticArrayType, } from "./astHelpers.js";
+/** Create the interface contract consumed by Reflect.equals for structural equality. */
+export function createInterfaceStrictEqualsMember(interfaceDeclaration) {
+    const range = interfaceDeclaration.name.range;
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression(STRICT_EQUALS_MEMBER_NAME, range), null, createInterfaceMemberFlags(interfaceDeclaration), null, TypeNode.createFunctionType([
+        createDefaultParameter("rawRef", createSimpleNamedType("Object", range), range),
+        createDefaultParameter("stack", createArrayType("usize", range), range),
+        createDefaultParameter("cache", createArrayType("usize", range), range),
+        createDefaultParameter("ignore", createStaticArrayType("i64", range), range),
+    ], createSimpleNamedType("bool", range), null, false, range), null, range);
+}
+/** Create the interface contract consumed by Reflect.toReflectedValue for member reporting. */
+export function createInterfaceAddReflectedValueKeyValuePairsMember(interfaceDeclaration) {
+    const range = interfaceDeclaration.name.range;
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression(ADD_REFLECTED_VALUE_KEY_VALUE_PAIRS_MEMBER_NAME, range), null, createInterfaceMemberFlags(interfaceDeclaration), null, TypeNode.createFunctionType([
+        createDefaultParameter("reflectedValue", createSimpleNamedType("i32", range), range),
+        createDefaultParameter("seen", createMapType("usize", "i32", range), range),
+        createDefaultParameter("ignore", createStaticArrayType("i64", range), range),
+    ], createSimpleNamedType("void", range), null, false, range), null, range);
+}
+function createInterfaceMemberFlags(interfaceDeclaration) {
+    return 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (interfaceDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0);
+}

package/lib/createStrictEqualsMember.js

@@ -1,5 +1,7 @@
-import { djb2Hash } from "./hash.js";
+import { HAS_EQ_OPERATOR_MEMBER_NAME, STRICT_EQUALS_MEMBER_NAME, createClassReflectionMemberPlan, } from "./ClassReflectionTransform.js";
 import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
+import { createArrayType, createDefaultParameter, createSimpleNamedType, createStaticArrayType } from "./astHelpers.js";
+import { createInheritedIgnoreListExpression } from "./createInheritedIgnoreListExpression.js";
 /**
  * This method creates a single FunctionDeclaration that allows Reflect.equals
  * to validate normal class member values.
@@ -9,35 +11,24 @@ import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
 export function createStrictEqualsMember(classDeclaration) {
     const range = classDeclaration.name.range;
     // __aspectStrictEquals(rawRef: Object, stackA: usize[], stackB: usize[], ignore: StaticArray<i64>): bool
-    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression("__aspectStrictEquals", range), null, 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression(STRICT_EQUALS_MEMBER_NAME, range), null, 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([
         // rawRef: Object,
-        createDefaultParameter("rawRef", TypeNode.createNamedType(TypeNode.createSimpleTypeName("Object", range), null, false, range), range),
+        createDefaultParameter("rawRef", createSimpleNamedType("Object", range), range),
         // stack: usize[]
         createDefaultParameter("stack", createArrayType("usize", range), range),
         // cache: usize[]
         createDefaultParameter("cache", createArrayType("usize", range), range),
         // ignore: StaticArray<i64>
-        createDefaultParameter("ignore", TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName("i64", range), null, false, range)], false, range), range),
+        createDefaultParameter("ignore", createStaticArrayType("i64", range), range),
     ], 
     // : bool
     createSimpleNamedType("bool", range), null, false, range), createStrictEqualsFunctionBody(classDeclaration), range);
 }
-/**
- * This method creates a simple name type with the given name and source range.
- *
- * @param {string} name - The name of the type.
- * @param {Range} range - The given source range.
- */
-function createSimpleNamedType(name, range) {
-    return TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range);
-}
-/**
- * This method creates an Array<name> type with the given range.
- *
- * @param {Range} range - The source range.
- */
-function createArrayType(name, range) {
-    return TypeNode.createNamedType(TypeNode.createSimpleTypeName("Array", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range)], false, range);
+/** Create the inherited marker used to tell strict equality to defer to @operator("=="). */
+export function createHasEqualsOperatorMember(classDeclaration) {
+    const range = classDeclaration.name.range;
+    // protected __aspectHasEqOperator(): bool { return true; }
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression(HAS_EQ_OPERATOR_MEMBER_NAME, range), null, 1024 /* CommonFlags.Protected */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([], createSimpleNamedType("bool", range), null, false, range), TypeNode.createBlockStatement([TypeNode.createReturnStatement(TypeNode.createTrueExpression(range), range)], range), range);
 }
 /**
  * This method creates the entire function body for __aspectStrictEquals.
@@ -47,7 +38,7 @@ function createArrayType(name, range) {
 function createStrictEqualsFunctionBody(classDeclaration) {
     const body = new Array();
     const range = classDeclaration.name.range;
-    const nameHashes = new Array();
+    const memberPlan = createClassReflectionMemberPlan(classDeclaration);
     const rawRef = TypeNode.createIdentifierExpression("rawRef", range);
     const classType = TypeNode.createNamedType(TypeNode.createSimpleTypeName(classDeclaration.name.text, range), classDeclaration.isGeneric
         ? classDeclaration.typeParameters.map((node) => TypeNode.createNamedType(TypeNode.createSimpleTypeName(node.name.text, range), null, false, range))
@@ -56,47 +47,26 @@ function createStrictEqualsFunctionBody(classDeclaration) {
     body.push(TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, TypeNode.createInstanceOfExpression(rawRef, classType, range), range), TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range));
     // Cast rawRef into an instance of the class
     body.push(TypeNode.createVariableStatement(null, [
-        TypeNode.createVariableDeclaration(TypeNode.createIdentifierExpression("ref", range), null, 8 /* CommonFlags.Const */, classType, TypeNode.createAssertionExpression(1 /* AssertionKind.As */, rawRef, classType, range), range)
+        TypeNode.createVariableDeclaration(TypeNode.createIdentifierExpression("ref", range), null, 8 /* CommonFlags.Const */, classType, TypeNode.createAssertionExpression(1 /* AssertionKind.As */, rawRef, classType, range), range),
     ], range));
-    // 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);
-                    body.push(createStrictEqualsIfCheck(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);
-                        body.push(createStrictEqualsIfCheck(methodDeclaration.name.text, hashValue, methodDeclaration.name.range));
-                        nameHashes.push(hashValue);
-                    }
-                    break;
-                }
-            }
-        }
+    // If this class, or a parent class, defines @operator("=="), strict equality uses that operator as authoritative.
+    body.push(createEqualsOperatorDelegationStatement(range));
+    // Generate a check for each reflected/equality-relevant class member.
+    for (const member of memberPlan.members) {
+        body.push(createStrictEqualsIfCheck(member.name, member.hash, member.range));
     }
     // if (isDefined(...)) super.__aspectStrictEquals(ref, stack, cache, ignore.concat([...props]));
-    body.push(createSuperCallStatement(classDeclaration, nameHashes));
+    body.push(createSuperCallStatement(classDeclaration, memberPlan.hashes));
     // return true;
     body.push(TypeNode.createReturnStatement(TypeNode.createTrueExpression(range), range));
     return TypeNode.createBlockStatement(body, range);
 }
-/**
- * This function generates a single IfStatement with a nested ReturnStatement
- * to validate a nested property on a given class.
- *
- * @param {string} name - The name of the property.
- * @param {Range} range - The source range for the given property.
- */
+/** Create the optional fast path that lets user-defined equality decide strict equality. */
+function createEqualsOperatorDelegationStatement(range) {
+    return TypeNode.createIfStatement(TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
+        TypeNode.createPropertyAccessExpression(TypeNode.createThisExpression(range), TypeNode.createIdentifierExpression(HAS_EQ_OPERATOR_MEMBER_NAME, range), range),
+    ], range), TypeNode.createReturnStatement(TypeNode.createBinaryExpression(76 /* Token.Equals_Equals */, TypeNode.createThisExpression(range), TypeNode.createIdentifierExpression("ref", range), range), range), null, range);
+}
 function createStrictEqualsIfCheck(name, hashValue, range) {
     const equalsCheck = TypeNode.createBinaryExpression(76 /* Token.Equals_Equals */, 
     // Reflect.equals(this.prop, ref.prop, stack, cache)
@@ -129,16 +99,6 @@ function createStrictEqualsIfCheck(name, hashValue, range) {
     // return false;
     TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range);
 }
-/**
- * Create a simple default parameter with a name and a type.
- *
- * @param {string} name - The name of the parameter.
- * @param {TypeNode} typeNode - The type of the parameter.
- * @param {Range} range - The source range of the parameter.
- */
-function createDefaultParameter(name, typeNode, range) {
-    return TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression(name, range), typeNode, null, range);
-}
 /**
  * This method creates a single property access and passes the given range to the AST.
  *
@@ -160,7 +120,7 @@ function createPropertyAccess(root, property, range) {
 function createSuperCallStatement(classDeclaration, nameHashes) {
     const range = classDeclaration.name.range;
     const ifStatement = TypeNode.createIfStatement(TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
-        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectStrictEquals", range), range),
+        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression(STRICT_EQUALS_MEMBER_NAME, range), range),
     ], range), TypeNode.createBlockStatement([
         TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, createSuperCallExpression(nameHashes, range), range), TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range),
     ], range), null, range);
@@ -173,15 +133,11 @@ function createSuperCallStatement(classDeclaration, nameHashes) {
  * @param {Range} range - The super call expression range
  */
 function createSuperCallExpression(hashValues, range) {
-    return TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectStrictEquals", range), range), null, [
+    return TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression(STRICT_EQUALS_MEMBER_NAME, range), range), null, [
         TypeNode.createIdentifierExpression("ref", range),
         TypeNode.createIdentifierExpression("stack", range),
         TypeNode.createIdentifierExpression("cache", range),
         // StaticArray.concat(ignore, [... props] as StaticArray<i64>)
-        TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("StaticArray", range), TypeNode.createIdentifierExpression("concat", range), range), null, [
-            TypeNode.createIdentifierExpression("ignore", range),
-            // [...] as StaticArray<i64>
-            TypeNode.createAssertionExpression(1 /* AssertionKind.As */, TypeNode.createArrayLiteralExpression(hashValues.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),
+        createInheritedIgnoreListExpression(hashValues, range),
     ], range);
 }

package/lib/index.js

@@ -1,6 +1,5 @@
 import { Transform } from "assemblyscript/dist/transform.js";
-import { createStrictEqualsMember } from "./createStrictEqualsMember.js";
-import { createAddReflectedValueKeyValuePairsMember } from "./createAddReflectedValueKeyValuePairsMember.js";
+import { appendGeneratedClassReflectionMembers, appendGeneratedInterfaceReflectionMembers, } from "./appendGeneratedClassReflectionMembers.js";
 // @ts-ignore
 export default class AspectTransform extends Transform {
     /**
@@ -23,13 +22,13 @@ function traverseStatements(statements) {
     // for each statement in the source
     for (const statement of statements) {
         // find each class declaration
-        if (statement.kind === 51 /* NodeKind.ClassDeclaration */) {
-            // cast and create a strictEquals function
-            const classDeclaration = statement;
-            classDeclaration.members.push(createStrictEqualsMember(classDeclaration));
-            classDeclaration.members.push(createAddReflectedValueKeyValuePairsMember(classDeclaration));
+        if (statement.kind === 52 /* NodeKind.ClassDeclaration */) {
+            appendGeneratedClassReflectionMembers(statement);
         }
-        else if (statement.kind === 59 /* NodeKind.NamespaceDeclaration */) {
+        else if (statement.kind === 58 /* NodeKind.InterfaceDeclaration */) {
+            appendGeneratedInterfaceReflectionMembers(statement);
+        }
+        else if (statement.kind === 60 /* NodeKind.NamespaceDeclaration */) {
             const namespaceDeclaration = statement;
             traverseStatements(namespaceDeclaration.members);
         }

package/lib/src/createAddReflectedValueKeyValuePairsMember.js

@@ -0,0 +1,176 @@
+// 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 55 /* 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 59 /* 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));
+}

package/lib/src/createGenericTypeParameter.js

@@ -0,0 +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);
+}

package/lib/src/createStrictEqualsMember.js

@@ -0,0 +1,187 @@
+import { djb2Hash } from "./hash.js";
+import { TypeNode, } from "assemblyscript/dist/assemblyscript.js";
+/**
+ * This method creates a single FunctionDeclaration that allows Reflect.equals
+ * to validate normal class member values.
+ *
+ * @param {ClassDeclaration} classDeclaration - The class that requires a new function.
+ */
+export function createStrictEqualsMember(classDeclaration) {
+    const range = classDeclaration.name.range;
+    // __aspectStrictEquals(rawRef: Object, stackA: usize[], stackB: usize[], ignore: StaticArray<i64>): bool
+    return TypeNode.createMethodDeclaration(TypeNode.createIdentifierExpression("__aspectStrictEquals", range), null, 256 /* CommonFlags.Public */ | 262144 /* CommonFlags.Instance */ | (classDeclaration.isGeneric ? 131072 /* CommonFlags.GenericContext */ : 0), null, TypeNode.createFunctionType([
+        // rawRef: Object,
+        createDefaultParameter("rawRef", TypeNode.createNamedType(TypeNode.createSimpleTypeName("Object", range), null, false, range), range),
+        // stack: usize[]
+        createDefaultParameter("stack", createArrayType("usize", range), range),
+        // cache: usize[]
+        createDefaultParameter("cache", createArrayType("usize", range), range),
+        // ignore: StaticArray<i64>
+        createDefaultParameter("ignore", TypeNode.createNamedType(TypeNode.createSimpleTypeName("StaticArray", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName("i64", range), null, false, range)], false, range), range),
+    ], 
+    // : bool
+    createSimpleNamedType("bool", range), null, false, range), createStrictEqualsFunctionBody(classDeclaration), range);
+}
+/**
+ * This method creates a simple name type with the given name and source range.
+ *
+ * @param {string} name - The name of the type.
+ * @param {Range} range - The given source range.
+ */
+function createSimpleNamedType(name, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range);
+}
+/**
+ * This method creates an Array<name> type with the given range.
+ *
+ * @param {Range} range - The source range.
+ */
+function createArrayType(name, range) {
+    return TypeNode.createNamedType(TypeNode.createSimpleTypeName("Array", range), [TypeNode.createNamedType(TypeNode.createSimpleTypeName(name, range), null, false, range)], false, range);
+}
+/**
+ * This method creates the entire function body for __aspectStrictEquals.
+ *
+ * @param {ClassDeclaration} classDeclaration - The class declaration.
+ */
+function createStrictEqualsFunctionBody(classDeclaration) {
+    const body = new Array();
+    const range = classDeclaration.name.range;
+    const nameHashes = new Array();
+    const rawRef = TypeNode.createIdentifierExpression("rawRef", range);
+    const classType = TypeNode.createNamedType(TypeNode.createSimpleTypeName(classDeclaration.name.text, range), classDeclaration.isGeneric
+        ? classDeclaration.typeParameters.map((node) => TypeNode.createNamedType(TypeNode.createSimpleTypeName(node.name.text, range), null, false, range))
+        : null, false, range);
+    // Check if the parameter is an instance of the class; return otherwise
+    body.push(TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, TypeNode.createInstanceOfExpression(rawRef, classType, range), range), TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range));
+    // Cast rawRef into an instance of the class
+    body.push(TypeNode.createVariableStatement(null, [
+        TypeNode.createVariableDeclaration(TypeNode.createIdentifierExpression("ref", range), null, 8 /* CommonFlags.Const */, classType, TypeNode.createAssertionExpression(1 /* AssertionKind.As */, rawRef, classType, range), range)
+    ], range));
+    // 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 55 /* NodeKind.FieldDeclaration */: {
+                    const fieldDeclaration = member;
+                    const hashValue = djb2Hash(member.name.text);
+                    body.push(createStrictEqualsIfCheck(member.name.text, hashValue, fieldDeclaration.range));
+                    nameHashes.push(hashValue);
+                    break;
+                }
+                // function declarations can be getters, check the get flag
+                case 59 /* NodeKind.MethodDeclaration */: {
+                    if (member.is(2048 /* CommonFlags.Get */)) {
+                        const methodDeclaration = member;
+                        const hashValue = djb2Hash(member.name.text);
+                        body.push(createStrictEqualsIfCheck(methodDeclaration.name.text, hashValue, methodDeclaration.name.range));
+                        nameHashes.push(hashValue);
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    // if (isDefined(...)) super.__aspectStrictEquals(ref, stack, cache, ignore.concat([...props]));
+    body.push(createSuperCallStatement(classDeclaration, nameHashes));
+    // return true;
+    body.push(TypeNode.createReturnStatement(TypeNode.createTrueExpression(range), range));
+    return TypeNode.createBlockStatement(body, range);
+}
+/**
+ * This function generates a single IfStatement with a nested ReturnStatement
+ * to validate a nested property on a given class.
+ *
+ * @param {string} name - The name of the property.
+ * @param {Range} range - The source range for the given property.
+ */
+function createStrictEqualsIfCheck(name, hashValue, range) {
+    const equalsCheck = TypeNode.createBinaryExpression(76 /* Token.Equals_Equals */, 
+    // Reflect.equals(this.prop, ref.prop, stack, cache)
+    TypeNode.createCallExpression(
+    // Reflect.equals
+    createPropertyAccess("Reflect", "equals", range), null, // types can be inferred by the compiler!
+    // arguments
+    [
+        // this.prop
+        TypeNode.createPropertyAccessExpression(TypeNode.createThisExpression(range), TypeNode.createIdentifierExpression(name, range), range),
+        // ref.prop
+        createPropertyAccess("ref", name, range),
+        // stack
+        TypeNode.createIdentifierExpression("stack", range),
+        // cache
+        TypeNode.createIdentifierExpression("cache", range),
+    ], range), createPropertyAccess("Reflect", "FAILED_MATCH", range), range);
+    // !ignore.includes("prop")
+    const includesCheck = TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, 
+    // ignore.includes("prop")
+    TypeNode.createCallExpression(
+    // ignore.includes
+    TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("ignore", range), TypeNode.createIdentifierExpression("includes", range), range), null, 
+    // (nameHash)
+    [TypeNode.createIntegerLiteralExpression(f64_as_i64(hashValue), range)], range), range);
+    // if (Reflect.equals(this.prop, ref.prop, stack, cache) === Reflect.FAILED_MATCH) return false;
+    return TypeNode.createIfStatement(
+    // Reflect.equals(this.prop, ref.prop, stack, cache) === Reflect.FAILED_MATCH
+    TypeNode.createBinaryExpression(97 /* Token.Ampersand_Ampersand */, includesCheck, equalsCheck, range), 
+    // return false;
+    TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range);
+}
+/**
+ * Create a simple default parameter with a name and a type.
+ *
+ * @param {string} name - The name of the parameter.
+ * @param {TypeNode} typeNode - The type of the parameter.
+ * @param {Range} range - The source range of the parameter.
+ */
+function createDefaultParameter(name, typeNode, range) {
+    return TypeNode.createParameter(0 /* ParameterKind.Default */, TypeNode.createIdentifierExpression(name, range), typeNode, null, range);
+}
+/**
+ * This method creates a single property access and passes the given range to the AST.
+ *
+ * @param {string} root - The name of the identifier representing the root.
+ * @param {string} property - The name of the identifier representing the property.
+ * @param {Range} range - The range of the property access.
+ */
+function createPropertyAccess(root, property, range) {
+    // root.property
+    return TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression(root, range), TypeNode.createIdentifierExpression(property, range), range);
+}
+/**
+ * This method creates the function call into super.__aspectStrictEquals,
+ * wrapping it in a check to make sure the super function is defined first.
+ *
+ * @param {ClassDeclaration} classDeclaration - The given class declaration.
+ * @param {number[]} nameHashes - A collection of hash values of the comparing class properties.
+ */
+function createSuperCallStatement(classDeclaration, nameHashes) {
+    const range = classDeclaration.name.range;
+    const ifStatement = TypeNode.createIfStatement(TypeNode.createCallExpression(TypeNode.createIdentifierExpression("isDefined", range), null, [
+        TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectStrictEquals", range), range),
+    ], range), TypeNode.createBlockStatement([
+        TypeNode.createIfStatement(TypeNode.createUnaryPrefixExpression(95 /* Token.Exclamation */, createSuperCallExpression(nameHashes, range), range), TypeNode.createReturnStatement(TypeNode.createFalseExpression(range), range), null, range),
+    ], range), null, range);
+    return ifStatement;
+}
+/**
+ * This method actually creates the super.__aspectStrictEquals function call.
+ *
+ * @param {number[]} hashValues - The collection of hashed property name values
+ * @param {Range} range - The super call expression range
+ */
+function createSuperCallExpression(hashValues, range) {
+    return TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createSuperExpression(range), TypeNode.createIdentifierExpression("__aspectStrictEquals", range), range), null, [
+        TypeNode.createIdentifierExpression("ref", range),
+        TypeNode.createIdentifierExpression("stack", range),
+        TypeNode.createIdentifierExpression("cache", range),
+        // StaticArray.concat(ignore, [... props] as StaticArray<i64>)
+        TypeNode.createCallExpression(TypeNode.createPropertyAccessExpression(TypeNode.createIdentifierExpression("StaticArray", range), TypeNode.createIdentifierExpression("concat", range), range), null, [
+            TypeNode.createIdentifierExpression("ignore", range),
+            // [...] as StaticArray<i64>
+            TypeNode.createAssertionExpression(1 /* AssertionKind.As */, TypeNode.createArrayLiteralExpression(hashValues.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);
+}

package/lib/src/emptyTransformer.js

@@ -0,0 +1,8 @@
+import { Transform } from "assemblyscript/dist/transform.js";
+/**
+ * Just an empty transformer.
+ */
+export default class AspectTransform extends Transform {
+    // @ts-ignore
+    afterParse(_parser) { }
+}

package/lib/src/hash.js

@@ -0,0 +1,15 @@
+/**
+ * A simple djb2hash that returns a hash of a given string. See http://www.cse.yorku.ca/~oz/hash.html
+ * for implementation details.
+ *
+ * @param {string} str - The string to be hashed
+ * @returns {number} The hash of the string
+ */
+export function djb2Hash(str) {
+    const points = Array.from(str);
+    let h = 5381;
+    for (let p = 0; p < points.length; p++)
+        // h = h * 33 + c;
+        h = (h << 5) + h + points[p].codePointAt(0);
+    return h;
+}

package/lib/src/index.js

@@ -0,0 +1,37 @@
+import { Transform } from "assemblyscript/dist/transform.js";
+import { createStrictEqualsMember } from "./createStrictEqualsMember.js";
+import { createAddReflectedValueKeyValuePairsMember } from "./createAddReflectedValueKeyValuePairsMember.js";
+// @ts-ignore
+export default class AspectTransform extends Transform {
+    /**
+     * This method results in a pure AST transform that inserts a strictEquals member
+     * into each ClassDeclaration.
+     *
+     * @param {Parser} parser - The AssemblyScript parser.
+     */
+    // @ts-ignore
+    afterParse(parser) {
+        // For backwards compatibility
+        let sources = parser.program ? parser.program.sources : parser.sources;
+        // for each program source
+        for (const source of sources) {
+            traverseStatements(source.statements);
+        }
+    }
+}
+function traverseStatements(statements) {
+    // for each statement in the source
+    for (const statement of statements) {
+        // find each class declaration
+        if (statement.kind === 52 /* NodeKind.ClassDeclaration */) {
+            // cast and create a strictEquals function
+            const classDeclaration = statement;
+            classDeclaration.members.push(createStrictEqualsMember(classDeclaration));
+            classDeclaration.members.push(createAddReflectedValueKeyValuePairsMember(classDeclaration));
+        }
+        else if (statement.kind === 60 /* NodeKind.NamespaceDeclaration */) {
+            const namespaceDeclaration = statement;
+            traverseStatements(namespaceDeclaration.members);
+        }
+    }
+}

package/package.json

@@ -1,23 +1,26 @@
 {
   "name": "@as-pect/transform",
-  "version": "8.1.0",
+  "version": "9.0.0",
   "description": "The transform used by the as-pect core and assembly packages to enable strict equality.",
   "main": "lib/index.js",
   "type": "module",
   "scripts": {
-    "tsc:all": "tsc"
+    "tsc:all": "tsc",
+    "test": "npm run tsc:all && node --test __tests__/*.test.js"
   },
   "author": "Joshua Tenner <tenner.joshua@gmail.com>",
   "license": "MIT",
   "dependencies": {
-    "assemblyscript": "^0.27.2"
+    "assemblyscript": "^0.28.19"
   },
   "devDependencies": {
-    "typescript": "^4.9.4"
+    "typescript": "^6.0.3"
   },
   "files": [
     "lib/",
     "init/"
   ],
-  "gitHead": "aa6aa77222efb41b3d9889ab190e452fa0f091c8"
+  "publishConfig": {
+    "access": "public"
+  }
 }