@as-pect/transform 8.0.1 → 9.0.0

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,187 +1,143 @@
-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 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 (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);
-}
+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.
+ *
+ * @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(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", 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", createStaticArrayType("i64", range), range),
+    ], 
+    // : bool
+    createSimpleNamedType("bool", range), null, false, range), createStrictEqualsFunctionBody(classDeclaration), 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.
+ *
+ * @param {ClassDeclaration} classDeclaration - The class declaration.
+ */
+function createStrictEqualsFunctionBody(classDeclaration) {
+    const body = new Array();
+    const range = classDeclaration.name.range;
+    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))
+        : 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));
+    // 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, memberPlan.hashes));
+    // return true;
+    body.push(TypeNode.createReturnStatement(TypeNode.createTrueExpression(range), range));
+    return TypeNode.createBlockStatement(body, range);
+}
+/** 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)
+    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);
+}
+/**
+ * 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(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);
+    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(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>)
+        createInheritedIgnoreListExpression(hashValues, range),
+    ], range);
+}

package/lib/emptyTransformer.js

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

package/lib/hash.js

@@ -1,15 +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;
-}
+/**
+ * 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/index.js

@@ -1,37 +1,36 @@
-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 === 51 /* 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 === 59 /* NodeKind.NamespaceDeclaration */) {
-            const namespaceDeclaration = statement;
-            traverseStatements(namespaceDeclaration.members);
-        }
-    }
-}
+import { Transform } from "assemblyscript/dist/transform.js";
+import { appendGeneratedClassReflectionMembers, appendGeneratedInterfaceReflectionMembers, } from "./appendGeneratedClassReflectionMembers.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 */) {
+            appendGeneratedClassReflectionMembers(statement);
+        }
+        else if (statement.kind === 58 /* NodeKind.InterfaceDeclaration */) {
+            appendGeneratedInterfaceReflectionMembers(statement);
+        }
+        else if (statement.kind === 60 /* NodeKind.NamespaceDeclaration */) {
+            const namespaceDeclaration = statement;
+            traverseStatements(namespaceDeclaration.members);
+        }
+    }
+}