compiler 0.0.2-preview.1

The Zena self-hosted compiler

Readme Files Dependencies Versions

compiler#

The Zena compiler, written in Zena. It parses, type-checks, and compiles Zena source code to WebAssembly (Wasm GC) and WebAssembly Text (WAT).

Usage#

Parsing a Single File#

Use compiler/parser to parse Zena source text into an AST (Module):

import { parse } from 'compiler/parser';

let ast = parse('export let answer = 42;', 'example.zena');

Loading and Checking a Program#

Use compiler (createCompiler and checkCompilation) with a CompilerHost to resolve imports across a module graph and type-check a program:

import {
  createCompiler, checkCompilation, buildStdlibConfig
} from 'compiler';
import { FsCompilerHost } from 'compiler/fs-host';

let stdlibRoot = '/stdlib';
let host = new FsCompilerHost(stdlibRoot);
let packages = buildStdlibConfig(stdlibRoot, 'host');
let compiler = createCompiler(host, {
  stdlibRoot,
  packages,
});

let result = await compiler.compile({
  entry: '/workspace/main.zena',
  target: 'host',
});
let checked = checkCompilation(result);

Compiling a File to WebAssembly#

Use compiler/compile-file to compile an entry file on disk to a .wasm or .wat output file:

import { compileFile } from 'compiler/compile-file';

let ok = await compileFile({
  entry: 'src/main.zena',
  outPath: 'out/main.wasm',
  stdlibRoot: '/stdlib',
});

Libraries#

  • compiler / compiler/compiler — compiler entry point (Compiler, createCompiler, checkCompilation, ProgramCheckResult)
  • compiler/compile-file — end-to-end file compilation (compileFile, CompileFileOptions)
  • compiler/tokenizer — lexer and token definitions (tokenize, Token, TokenType)
  • compiler/parser — recursive-descent parser (parse, Parser)
  • compiler/ast — AST node definitions (Node, Module, Statement, Expression, TypeAnnotation)
  • compiler/visitor — AST traversal helpers (walk, Visitor)
  • compiler/scope — lexical scope and symbol resolution (ScopeBuilder, ScopeResult, Symbol)
  • compiler/checker — static type checker (checkModule, CheckResult)
  • compiler/semantic-model — semantic queries over a checked module (SemanticModel)
  • compiler/types — compiler type representations (Type, ClassType, FunctionType, typeToString)
  • compiler/diagnostics — compiler diagnostics and source spans (Diagnostic, DiagnosticCode, DiagnosticSeverity, SourceSpan)
  • compiler/package-manifest — zena-package.json manifest and workspace loader (loadWorkspace, loadPackageMap)
  • compiler/module-resolver — package and relative module specifier resolution (ModuleResolver, PackageConfig)
  • compiler/library-loader — module graph loader (LibraryLoader, CompilerHost, SourceFile)
  • compiler/codegen/binary-generator — WebAssembly GC binary emitter (BinaryGenerator)
  • compiler/codegen/wat-generator — WebAssembly Text (WAT) emitter (WatGenerator)

License#

MIT

105.3 KiB Raw
import {
  Referrer, ReachabilityContext, SpecializerInterface,
} from './context.zena';
import { SemanticModel, memberKeyOf } from '../../semantic-model.zena';
import { Type, ClassType, InterfaceType, FunctionType, TypeParameterType, VoidType, BooleanType, I32Type, MethodInfo, FieldInfo, FunctionDeclInfo, AnyRefType, RecordType, releaseMemberOf, synthesizedRelease } from '../../types.zena';
import {
  Node, ClassDeclaration, FieldDefinition, MethodDefinition, hasEnsuresClause, AccessorDeclaration, SetterInfo, VariableDeclaration, FunctionDeclaration, IdentifierPattern, Decorator, decoratorStringArg, Identifier, SymbolPropertyName, MemberExpression, TypeParameter, SealedVariant, InterfaceDeclaration, Expression, MixinDeclaration, BlockStatement, SuperInitializer, isSymbolFieldDeclaration,
} from '../../ast.zena';
import { WasmStruct, WasmField, WasmGlobal, WasmFunction, ClassCodegenInfo } from '../wasm-module.zena';
import {
  ValType, ValTypeVoid, ValTypeI32, ValTypeRefNull, ValTypeAnyRef, ValTypeRef, ValTypeStructRef, ValTypeFuncRef,
} from '../wasm.zena';
import { SymbolId, noSymbolId } from '../../scope/symbol.zena';
import { Set } from 'zena:collections';

import { getClassKey, getInterfaceKey, getInterfaceConstructorBaseName, getClassMethodKey, getClassInterfaceKey, getSignatureKey, matchOverload, collectMixinMembers, getMemberRootClass, getClassPrivateFieldKey, getSpecializedFunctionKey, getSpecializedName, isConcrete, MixinKey, containsErasedType, findMixinDeclaration } from '../codegen-utils.zena';
import { typeToValType, mapReturnTypeToWasmResults, mapParamTypeToWasmParams, substituteTypeParamsInCodegen, substituteTypeParamsInClassContext, getClassTypeParameters, getInterfaceTypeParameters, interfaceMethodOverloads, getClosureStruct } from '../type-mapping.zena';
import { growable } from 'zena:core';

/**
 * A struct field whose class type was not yet registered when the
 * struct was laid out, so its valtype was baked as the `structref`
 * fallback. Discovery can register (and instantiate) the class AFTER
 * that bake — a body walked late does exactly this — and then the
 * class's method signatures are precise while the field is erased,
 * which fails receiver conformance in lowering. Recorded at the bake
 * site and re-resolved in place once discovery settles.
 */
final class ErasedFieldBake {
  field: WasmField;
  fieldType: Type;
  new(this.field, this.fieldType);
}

/**
 * Records a mixin's private scope on the function that holds `node`'s body.
 *
 * A mixin member and a class member can share a name; the class's wins, the
 * way an override does. Both still register under that one name, and
 * `registerClassMethod` hands the second caller the function the first one
 * created. Writing the mixin's scope onto it unconditionally would make the
 * class's own body resolve its `#` names in the mixin's namespace, where
 * lowering cannot find them.
 */
export function applyMixinPrivateScope(
    fn: WasmFunction, node: Node | null, scope: String | null): void {
  if (scope == null) {
    return;
  }
  let key = scope as String;
  if (key == "" || fn.node !== node) {
    return;
  }
  fn.privateScopeKey = key;
}

/**
 * Specializer handles the monomorphization of generic classes and functions,
 * generating runtime specialized structures, vtables, and method wrappers.
 */
export final class Specializer implements SpecializerInterface {
  pass: ReachabilityContext;

  /** Fields baked erased before their class type existed; see ErasedFieldBake. */
  #erasedFieldBakes = new Array<ErasedFieldBake>();

  new(this.pass);

  /**
   * Re-resolves fields that were baked as `structref` because their
   * class type had no registration at layout time. Runs once discovery
   * has fully settled — the same moment the settled layout pass
   * catches structs that were instantiated late — so a field of a
   * late-registered class agrees with that class's (now precise)
   * method signatures. A field whose type still does not resolve stays
   * erased, which is the pre-existing consistent-erasure behavior.
   *
   * Mutates the WasmField in place: inherited fields are shared
   * instances between super- and subclass structs, and the write must
   * be visible through both.
   */
  refreshErasedFieldTypes(): void {
    for (let bake in this.#erasedFieldBakes) {
      let valType = typeToValType(this.pass.wasm, bake.fieldType);
      if (valType is ValTypeRef) {
        bake.field.type = valType;
      }
    }
  }

  /**
   * Create the globals backing a class's static fields. One global per
   * field, named for the class rather than any specialization, because a
   * static cannot name the class's type parameters and so does not vary
   * with them.
   *
   * Driven by reaching a static, NOT by instantiating the class: a
   * generic class whose statics are all anyone uses is never
   * instantiated, and its counter still has to exist.
   */
  discoverStaticFields(classType: ClassType, cd: ClassDeclaration,
      model: SemanticModel): void {
    for (let member in cd.body) {
      if (!(member is FieldDefinition)) { continue; }
      if (!member.isStatic) { continue; }
      // `static symbol sym;` parses as a static field annotated `symbol`,
      // but a symbol is an identity rather than storage: it has no value,
      // so there is no global to hold it and no type to give one.
      if (isSymbolFieldDeclaration(member)) { continue; }
      let fieldName = memberKeyOf(model, member.name as Node);
      if (fieldName == "") { continue; }
      let name = `${cd.name.name}_${fieldName}`;
      // One global per class, not per specialization: two instantiations
      // of a generic class share the cell, and reaching a static can now
      // get here without any instantiation at all.
      var already = false;
      for (let existing in this.pass.wasm.globals) {
        if (existing.name == name) { already = true; }
      }
      if (already) { continue; }
      let fType = if (classType.staticMembers.has(fieldName)) {
        classType.staticMembers[fieldName].type
      } else {
        model.getNodeType(member)
      };
      let vType = typeToValType(this.pass.wasm, fType as Type);
      let initExp: Expression | null = if (member.value != null) { member.value as Expression } else { null };
      this.pass.wasm.globals.push(
          new WasmGlobal(name, fieldName, vType, true, initExp, null, model));
    }
  }

  /**
   * The field decorator applications in `classType`'s chain whose body
   * reads its `context` (docs/design/decorators.md, "The decorated
   * field's context"). For each: the decorated field's accessors are
   * registered on the host and reached, whether or not the program
   * reads the field directly, and one closure-ABI wrapper per accessor
   * is minted — `context.get`'s `(ctx, host) -> T` and `context.set`'s
   * `(ctx, host, value)` — keyed by the application's class key in
   * `decoratorContextWrappers`, where lowering finds them. The field's
   * name is noted as a string literal, since `context.name` lowers to
   * one.
   */
  #rootDecoratorContexts(classType: ClassType, model: SemanticModel): void {
    let decorated = classType.decoratedFields;
    if (decorated == null) {
      return;
    }
    let hostId = (classType.genericSource ?? classType).symbolId;
    let cd = if (let (true, decl) = this.pass.classDecls.get(hostId)) decl else null;
    var chain = classType.superType;
    while (chain != null && chain.isMixinIntermediate) {
      let sc = chain;
      chain = sc.superType;
      if (sc.decoratorSubjectName == null || sc.decoratorFieldName == null) {
        continue;
      }
      let fieldName = sc.decoratorFieldName as String;
      if (!decorated.has(fieldName)) {
        continue;
      }
      let df = decorated[fieldName];
      let source = df.decorator.genericSource ?? df.decorator;
      let decl = findMixinDeclaration(this.pass.program, df.decorator);
      if (decl == null) {
        continue;
      }
      let subjectOpt = decl.decoratorSubject;
      if (subjectOpt == null) {
        continue;
      }
      let subjectNode = subjectOpt as FieldDefinition;
      if (!(subjectNode.name is Identifier)) {
        continue;
      }
      // Rooted only for a decorator whose body reads `context`.
      let decId = source.symbolId;
      let nodeModel = if (this.pass.classModels.has(decId)) {
        this.pass.classModels[decId]
      } else {
        model
      };
      let contextSym = nodeModel.resolveDeclaration(subjectNode.name);
      if (contextSym == null || !contextSym.decoratorContextUsed) {
        continue;
      }
      let appKey = getClassKey(sc) as String;
      if (this.pass.wasm.decoratorContextWrappers.has(`${appKey}::get`)) {
        continue;
      }
      // The subject accessor, registered under the field's name as the
      // member loop registers it (analysis.zena, the decorator path).
      let subject = sc.decoratorSubjectName as String;
      var accNode: AccessorDeclaration | null = null;
      for (let m in decl.body) {
        if (m is AccessorDeclaration && memberKeyOf(nodeModel, m.name as Node) == subject) {
          accNode = m as AccessorDeclaration;
        }
      }
      if (accNode == null) {
        continue;
      }
      let acc = accNode as AccessorDeclaration;
      let scope = sc.privateScopeKey;
      let hostType: Type = sc.onType ?? new AnyRefType();
      let fieldType = df.fieldType;
      // The record `context` lowers to, at this application's field
      // type: discovered here because the body's own walk sees it at
      // the decorator's type parameter, and the host constructor lowers
      // an initializer that reads it under this application.
      let contextProps = new Map<String, Type>();
      let stringClass = this.pass.wasm.stringClass;
      if (stringClass != null) {
        contextProps["name"] = stringClass as Type;
      }
      contextProps["get"] = new FunctionType(growable<Type>([hostType]), fieldType);
      if (acc.setter != null) {
        contextProps["set"] = new FunctionType(growable<Type>([hostType, fieldType]), new VoidType());
      }
      this.pass.typeLowerer.discoverType(
          new RecordType(contextProps, null, null, false), nodeModel);
      if (acc.getter != null) {
        let regG = this.registerClassMethod(classType, cd, `get#${fieldName}`, acc, false, false, null, nodeModel, null);
        regG.declaringType = sc;
        applyMixinPrivateScope(regG, acc, scope);
        this.pass.wasm.addFunction(regG);
        this.pass.markFunctionReached(regG);
        let getFt = new FunctionType(growable<Type>([hostType]), fieldType);
        this.#mintDecoratorContextWrapper(`${appKey}::get`, getFt, regG, nodeModel);
      }
      let {setter} = acc;
      if (setter != null) {
        let regS = this.registerClassMethod(classType, cd, `set#${fieldName}`, setter, false, false, null, nodeModel, null);
        regS.declaringType = sc;
        applyMixinPrivateScope(regS, setter, scope);
        this.pass.wasm.addFunction(regS);
        this.pass.markFunctionReached(regS);
        let setFt = new FunctionType(growable<Type>([hostType, fieldType]), new VoidType());
        this.#mintDecoratorContextWrapper(`${appKey}::set`, setFt, regS, nodeModel);
      }
      this.pass.visitor.noteStringLiteral(fieldName);
    }
  }

  /** One `context.get`/`context.set` wrapper: the closure ABI around `target`. */
  #mintDecoratorContextWrapper(key: String, ft: FunctionType, target: WasmFunction, model: SemanticModel): void {
    let wrapperParams = growable<ValType>([new ValTypeStructRef()]);
    for (let p in ft.parameters) {
      mapParamTypeToWasmParams(this.pass.wasm, p, wrapperParams);
    }
    let wrapperReturns = new Array<ValType>();
    mapReturnTypeToWasmResults(this.pass.wasm, ft.returnType, wrapperReturns);
    let sig = this.pass.wasm.getSignature(wrapperParams, wrapperReturns);
    let wrapper = new WasmFunction(sig, null, model);
    let targetName = if (target.name != null) target.name as String else "accessor";
    wrapper.name = `${targetName}_context_${getSignatureKey(ft)}`;
    wrapper.decoratorAccessorTarget = target;
    wrapper.isReferenceTaken = true;
    this.pass.wasm.decoratorContextWrappers[key] = wrapper;
    this.pass.wasm.addFunction(wrapper);
    this.pass.markFunctionReached(wrapper);
    this.pass.reachablyNamedClosures.add(getClosureStruct(this.pass.wasm, ft));
  }

  instantiateClassType(classType: ClassType, model: SemanticModel): void {
    if (!this.pass.isRtaActive) {
      return;
    }
    if (!isConcrete(classType) || containsErasedType(classType as Type)) {
      return;
    }
    let cha = this.pass.cha;
    let typeLowerer = this.pass.typeLowerer;
    let cKey = getClassKey(classType) as String;
    if (this.pass.instantiatedSpecializedClasses.has(cKey)) {
      return;
    }
    if (this.pass.instantiationClosed) {
      throw new Error("class instantiated after layout began: " + cKey);
    }
    this.pass.instantiatedSpecializedClasses.add(cKey);
    cha.registerInstantiatedClass(classType);
    // Values of this specialization exist, whoever first mentioned it:
    // list it, so a member reached on the generic later fans out over
    // it. Discovery passes over mentions made while laying out a class
    // the module will never emit, and this is where such a
    // specialization rejoins the register if it turns out to be real.
    this.pass.noteSpecialization(classType, model);
    this.#rootDecoratorContexts(classType, model);

    // Instantiation promotes constructors only for DEMANDED generics —
    // ones with a `new` site somewhere (queueExplicitCtor records the
    // demand; concrete sites also pend by key). Unconditional
    // promotion emitted a constructor nothing calls in every
    // literal-only String program — string_from_shared builds its
    // String with struct.new directly.
    if (this.pass.ctorDemandedGenerics.has((classType.genericSource ?? classType).symbolId)) {
      if (let (true, funcs) = this.pass.wasm.classMethods.get(cKey)) {
        for (let func in funcs) {
          if (func.methodName != null &&
              isConstructorMethodName(func.methodName as String) &&
              !this.pass.reachedFunctionsSet.has(func)) {
            this.pass.wasm.addFunction(func);
            this.pass.markFunctionReached(func);
            // See #reachSuperConstructors: `: super(...)` calls it.
            this.#reachSuperConstructors(func);
          }
        }
      }
    }

    /*
    if (let (true, funcs) = this.pass.wasm.classMethods.get(cKey)) {
      for (let func in funcs) {
        if (!this.pass.reachedFunctionsSet.has(func)) {
          this.pass.wasm.addFunction(func);
          this.pass.markFunctionReached(func);
        }
      }
    }
    */

    // A specialization's concrete class type arguments are
    // instantiated with it: if `FixedArray<String>` exists then String
    // values exist, and its `contains` lowers to String's `==`. While
    // String was instantiated unconditionally this held by accident.
    let typeArguments = classType.typeArguments;
    if (typeArguments != null) {
      for (let ta in typeArguments) {
        if (ta is ClassType && isConcrete(ta)) {
          if (getClassKey(ta) != getClassKey(classType)) {
            this.instantiateClassType(ta, this.pass.getClassModel(ta));
          }
        }
      }
    }

    let unspecC = classType.genericSource ?? classType;
    let classId = unspecC.symbolId;
    this.pass.instantiatedClasses.add(classId);
    if (this.pass.specializedClassTypes.has(classId)) {
      let list = this.pass.specializedClassTypes[classId];
      for (let specCt in list) {
        this.instantiateClassType(specCt, this.pass.getClassModel(specCt));
      }
    }

    // Keep == and hashCode for any instantiated class if they exist,
    // as they can be called virtually by generic operations and HashMap/HashSet.
    let unspecModel = this.pass.getClassModel(classType);

    // Propagate all reached members of the base class to this new instantiation
    if (let (true, reachedSet) = this.pass.reachedClassMembers.get(classId)) {
      let rcKeys = reachedSet.keys();
      for (let memberNodeId in rcKeys) {
        let memberModel = if (this.pass.nodeIdToModel.has(memberNodeId)) {
          this.pass.nodeIdToModel[memberNodeId]
        } else {
          unspecModel
        };
        this.pass.queueReferrer(new Referrer(false, noSymbolId, memberNodeId, memberModel, classType, false));
      }
    }
    if (let (true, reachedSet) = this.pass.reachedReachableClassMembers.get(classId)) {
      let rrKeys = reachedSet.keys();
      for (let memberNodeId in rrKeys) {
        let memberModel = if (this.pass.nodeIdToModel.has(memberNodeId)) {
          this.pass.nodeIdToModel[memberNodeId]
        } else {
          unspecModel
        };
        this.pass.queueReferrer(new Referrer(false, noSymbolId, memberNodeId, memberModel, classType, true));
      }
    }
    // ==/hashCode referrers follow the same evidence as their slots:
    // without erased equality anywhere, instantiation alone is not a
    // reason to emit them. Direct `a == b` on concrete receivers
    // reaches the operator through its own member records.
    this.pass.reachEqualityBelowComparedBase(classType);
    if (this.pass.equalityDispatchUsed) {
      this.pass.reachEqualityOf(classType);
      let hashMethod = cha.findImplementingMethod(classType, "hashCode");
      if (hashMethod != null) {
        this.pass.queueReferrer(new Referrer(false, noSymbolId, (hashMethod as Node).id as i32, this.pass.getNodeModel(hashMethod as Node, unspecModel), classType, this.pass.currentReachable));
      }
    }

    if (classType.superType != null) {
      let superType = classType.superType as ClassType;
      this.instantiateClassType(superType, this.pass.getClassModel(superType));
    }

    typeLowerer.discoverType(classType, model);

    let classDecl: Node | null = if (this.pass.classDecls.has(classId)) {
      this.pass.classDecls[classId]
    } else {
      null
    };

    if (classDecl is ClassDeclaration) {
      this.discoverStaticFields(classType, classDecl, model);

      // Check if there is an explicit constructor
      var hasExplicitCtor = false;
      for (let member in classDecl.body) {
        if (member is MethodDefinition) {
          if (member.isConstructor) {
            hasExplicitCtor = true;
          }
        }
      }

      if (!hasExplicitCtor && !classType.isExtension && !classType.isMixinIntermediate && !containsErasedType(classType as Type)) {
        this.registerClassMethod(classType, classDecl, "<constructor>", null, false, false, null, model);
      }

      if (synthesizedRelease(classType)) {
        // A class whose only release action is its fields: the checker
        // synthesized its release member (a resource's `:dispose`, a
        // `scoped T` class's `[release]`), and lowering emits the field
        // glue as its whole body.
        let dFunc = this.registerClassMethod(classType, classDecl, releaseMemberOf(classType), null, false, false, null, model);
        dFunc.isSyntheticRelease = true;
      }

      // Discover constructor and field initializers
      for (let member in classDecl.body) {
        if (member is MethodDefinition) {
          if (member.isConstructor) {
            this.pass.queueReferrer(new Referrer(false, noSymbolId, (member as Node).id as i32, model, classType, this.pass.currentReachable));
          }
        } else if (member is FieldDefinition) {
          if (member.value != null) {
            this.pass.queueReferrer(new Referrer(false, noSymbolId, (member as Node).id as i32, model, classType, this.pass.currentReachable));
          }
        }
      }
    } else if (classDecl is SealedVariant) {
      if (!classType.isExtension && !classType.isMixinIntermediate && !containsErasedType(classType as Type)) {
        this.registerClassMethod(classType, null, "<constructor>", null, false, false, null, model);
      }
    } else if (classDecl != null) {
      if (!classType.isExtension && !classType.isMixinIntermediate && !containsErasedType(classType as Type)) {
        this.registerClassMethod(classType, null, "<constructor>", null, false, false, null, model);
      }
      if (classDecl is MixinDeclaration) {
        for (let composed in classType.mixins) {
          let compLookupId = (composed.genericSource ?? composed).symbolId;
          if (this.pass.classDecls.has(compLookupId)) {
            let cDecl = this.pass.classDecls[compLookupId];
            if (cDecl is MixinDeclaration) {
              let compModel = if (this.pass.classModels.has(compLookupId)) this.pass.classModels[compLookupId] else model;
              for (let member in cDecl.body) {
                if (member is FieldDefinition) {
                  if (member.value != null) {
                    this.pass.queueReferrer(new Referrer(false, noSymbolId, (member as Node).id as i32, compModel, classType, this.pass.currentReachable));
                  }
                }
              }
            }
          }
        }
        for (let member in classDecl.body) {
          if (member is FieldDefinition) {
            if (member.value != null) {
              this.pass.queueReferrer(new Referrer(false, noSymbolId, (member as Node).id as i32, model, classType, this.pass.currentReachable));
            }
          }
        }
      }
    }
  }

  registerSpecializedClass(ct: ClassType, classDecl: Node | null, sourceModel: SemanticModel): void {
    if (!this.preRegisterClassStruct(ct)) {
      return;
    }
    this.finishSpecializedClass(ct, classDecl, sourceModel);
  }

  preRegisterClassStruct(ct: ClassType): boolean {
    let cKey = getClassKey(ct);
    if (this.pass.wasm.classInfos.has(cKey)) {
      return false;
    }

    // 1. Pre-register empty structs
    let structName = cKey as String;
    let emptyStruct = new WasmStruct(structName, new Array<WasmField>());
    emptyStruct.classType = ct;
    if (!ct.isExtension) {
      this.pass.wasm.types.push(emptyStruct);
    }
    let info = new ClassCodegenInfo(emptyStruct);
    this.pass.wasm.classInfos[cKey] = info;

    let emptyVTableStruct = new WasmStruct(structName + "_VTable", new Array<WasmField>());
    emptyVTableStruct.classType = ct;
    if (!ct.isExtension) {
      this.pass.wasm.types.push(emptyVTableStruct);
    }
    info.vtableStructType = emptyVTableStruct;
    return true;
  }

  finishSpecializedClass(ct: ClassType, classDecl: Node | null, sourceModel: SemanticModel): void {
    let cKey = getClassKey(ct);
    let info = this.pass.wasm.classInfos[cKey];
    let emptyStruct = info.structType;
    let emptyVTableStruct = info.vtableStructType as WasmStruct;
    let ctVtable = this.pass.wasm.classVtable(cKey);

    let ctParams = getClassTypeParameters(ct);
    let isErasedClass = containsErasedType(ct as Type);

    // 2. Link super types
    let {superType} = ct;
    if (superType != null) {
      let superCt = superType;
      this.pass.typeLowerer.discoverType(superCt, sourceModel);
      
      let superKey = getClassKey(superCt);
      if (let (true, superInfo) = this.pass.wasm.classInfos.get(superKey)) {
        if (!superCt.isExtension) {
          emptyStruct.superStruct = superInfo.structType;
          var hasSub = false;
          for (let existingSub in superInfo.subclasses) {
            if (existingSub === info) {
              hasSub = true;
              break;
            }
          }
          if (!hasSub) {
            superInfo.subclasses.push(info);
          }
          let {vtableStructType} = superInfo;
          if (vtableStructType != null) {
            emptyVTableStruct.superStruct = vtableStructType;
          }
        }
      }

      let superVtable = this.pass.wasm.classVtable(superKey);
      if (superVtable.length > 0 || ctVtable.length > 0) {
        let newVTable = new Array<String>();
        for (let methName in superVtable) {
          newVTable.push(methName);
        }
        for (let methName in ctVtable) {
          var hasMeth = false;
          for (let existing in newVTable) {
            if (existing == methName) { hasMeth = true; break; }
          }
          if (!hasMeth) {
            newVTable.push(methName);
          }
        }
        while (ctVtable.length > 0) {
          ctVtable.pop();
        }
        for (let m in newVTable) {
          ctVtable.push(m);
        }
      }
    }

    if (ct.derivesEquality && !isErasedClass) {
      var hasEq = false;
      var hasHash = false;
      for (let existing in ctVtable) {
        if (existing == "==") { hasEq = true; }
        if (existing == "hashCode") { hasHash = true; }
      }
      if (!hasEq) {
        ctVtable.push("==");
      }
      if (!hasHash) {
        ctVtable.push("hashCode");
      }
    }

    // 3. Discover referenced types in members (fields)
    let typeLowerer = this.pass.typeLowerer;
    let cha = this.pass.cha;
    for (let pair in ct.members) {
      if (pair.value is FieldInfo) {
        let resolvedType = substituteTypeParamsInCodegen(this.pass.wasm, ctParams, ct.typeArguments, pair.value.type);
        typeLowerer.discoverType(resolvedType, sourceModel);
      }
    }

    let specIfaces = cha.collectAllImplementedInterfaces(ct);
    for (let iface in specIfaces) {
      typeLowerer.discoverType(iface, sourceModel);
    }

    // An ERASURE gets a struct and nothing else. Erased signatures and
    // fields name the struct, so it has to exist — but no value is ever
    if (isErasedClass || ct.isMixinIntermediate) {
      this.populateClassStructAndMethods(ct, classDecl, sourceModel);
      return;
    }

    // 4. Populate VTable slots and structs
    let allMembers = new Array<Node>();
    let allScopes = new Array<String>();
    let allModels = new Array<SemanticModel>();
    let allDecls = new Array<Node>();
    let allDeclaringTypes = new Array<ClassType | null>();
    let classDeclCd = if (classDecl is ClassDeclaration) classDecl else null;
    let mixinDeclMd = if (classDecl is MixinDeclaration) classDecl else null;
    if (classDeclCd != null) {
      var mixinSup = ct.superType;
      let mixinChain = new Array<ClassType>();
      while (mixinSup != null && mixinSup.isMixinIntermediate) {
        mixinChain.push(mixinSup);
        mixinSup = mixinSup.superType;
      }
      var mci = mixinChain.length - 1;
      while (mci >= 0) {
        let mSup = mixinChain[mci];
        let mLookupId = (mSup.genericSource ?? mSup).symbolId;
        if (this.pass.classDecls.has(mLookupId)) {
          let mDecl = this.pass.classDecls[mLookupId];
          if (mDecl is MixinDeclaration) {
            for (let composed in mSup.mixins) {
              let compLookupId = (composed.genericSource ?? composed).symbolId;
              if (this.pass.classDecls.has(compLookupId)) {
                let cDecl = this.pass.classDecls[compLookupId];
                if (cDecl is MixinDeclaration) {
                  let compModel = if (this.pass.classModels.has(compLookupId)) this.pass.classModels[compLookupId] else sourceModel;
                  for (let ms in (cDecl as MixinDeclaration).body) {
                    allMembers.push(ms);
                    allScopes.push(composed.privateScopeKey ?? "");
                    allModels.push(compModel);
                    allDecls.push(cDecl);
                    allDeclaringTypes.push(mSup);
                  }
                }
              }
            }
            let mModel = if (this.pass.classModels.has(mLookupId)) this.pass.classModels[mLookupId] else sourceModel;
            for (let ms in (mDecl as MixinDeclaration).body) {
              allMembers.push(ms);
              allScopes.push(mSup.privateScopeKey ?? "");
              allModels.push(mModel);
              allDecls.push(mDecl);
              allDeclaringTypes.push(mSup);
            }
          }
        }
        mci -= 1;
      }
      for (let ms in classDeclCd.body) {
        allMembers.push(ms);
        allScopes.push("");
        allModels.push(sourceModel);
        allDecls.push(classDeclCd);
        allDeclaringTypes.push(null);
      }
    } else if (mixinDeclMd != null) {
      for (let composed in ct.mixins) {
        let compLookupId = (composed.genericSource ?? composed).symbolId;
        if (this.pass.classDecls.has(compLookupId)) {
          let cDecl = this.pass.classDecls[compLookupId];
          if (cDecl is MixinDeclaration) {
            let compModel = if (this.pass.classModels.has(compLookupId)) this.pass.classModels[compLookupId] else sourceModel;
            for (let ms in (cDecl as MixinDeclaration).body) {
              allMembers.push(ms);
              allScopes.push(composed.privateScopeKey ?? "");
              allModels.push(compModel);
              allDecls.push(cDecl);
              allDeclaringTypes.push(ct);
            }
          }
        }
      }
      for (let ms in mixinDeclMd.body) {
        allMembers.push(ms);
        allScopes.push(ct.privateScopeKey ?? "");
        allModels.push(sourceModel);
        allDecls.push(mixinDeclMd);
        allDeclaringTypes.push(ct);
      }
    }

    var vtMemberIdx = -1;
    for (let ms in allMembers) {
      vtMemberIdx += 1;
      if (ms is MethodDefinition) {
        if (ms.isStatic) { continue; }
        if (ms.isConstructor) { continue; }
        let methName = memberKeyOf(sourceModel, ms.name as Node);
        if (methName != "") {
          var vtableMethName = methName;
          if (ct.members.has(methName)) {
            let mInfo = ct.members[methName];
            if (mInfo.type is FunctionType) {
              let ft = mInfo.type as FunctionType;
              let specificType = matchOverload(sourceModel, ft, ms);
              if (specificType != null) {
                vtableMethName = methName + getSignatureKey(specificType);
              }
            }
          }
          
          var found = false;
          for (let existing in ctVtable) {
            if (existing == vtableMethName) { found = true; }
          }
          // Private methods are never virtual (member-lookup.md §6):
          // they get no vtable slot and are always called directly.
          let isPrivateMeth = methName.length > 0 && methName.sliceBytes(0, 1) == "#";
          // Neither is a GENERIC method: a slot holds one `ref.func`
          // of one signature, and a generic method has no single body
          // — it exists once per specialization, each with its own.
          let isGenericMeth = ms.typeParameters != null &&
              (ms.typeParameters as GrowableArray<TypeParameter>).length > 0;
          if (!found && !ms.isConstructor && methName != "<constructor>" && !isPrivateMeth && !isGenericMeth && !ct.isExtension) {
            ctVtable.push(vtableMethName);
          }
        }
      } else if (ms is AccessorDeclaration) {
        if (ms.isStatic) { continue; }
        let accName = this.#registeredAccessorName(
            memberKeyOf(sourceModel, ms.name as Node), allDeclaringTypes[vtMemberIdx]);
        // Private-named accessors are lexical, never virtual: no
        // vtable slots (like private methods).
        if (accName != "" &&
            !(accName.length > 0 && accName.sliceBytes(0, 1) == "#")) {
          if (ms.getter != null) {
            let getterName = "get#" + accName;
            var found = false;
            for (let existing in ctVtable) {
              if (existing == getterName) { found = true; break; }
            }
            if (!found && !ct.isExtension) {
              ctVtable.push(getterName);
            }
          }
          if (ms.setter != null) {
            let setterName = "set#" + accName;
            var found = false;
            for (let existing in ctVtable) {
              if (existing == setterName) { found = true; break; }
            }
            if (!found && !ct.isExtension) {
              ctVtable.push(setterName);
            }
          }
        }
      } else if (ms is FieldDefinition) {
        if (ms.isStatic) { continue; }
        let fieldName = memberKeyOf(sourceModel, ms.name as Node);
        if (this.#isDecoratedField(ct, fieldName)) { continue; }
        if (ms.setterName != null && fieldName != "") {
          let getterName = "get#" + fieldName;
          var found = false;
          for (let existing in ctVtable) {
            if (existing == getterName) { found = true; break; }
          }
          if (!found) { ctVtable.push(getterName); }
        }
        if (ms.isAbstract && fieldName != "") {
          let getterName = "get#" + fieldName;
          var found = false;
          for (let existing in ctVtable) {
            if (existing == getterName) { found = true; break; }
          }
          if (!found) { ctVtable.push(getterName); }
          if (ms.mutability != null && ms.mutability == "var") {
            let setterName = "set#" + fieldName;
            var foundS = false;
            for (let existing in ctVtable) {
              if (existing == setterName) { foundS = true; break; }
            }
            if (!foundS) { ctVtable.push(setterName); }
          }
        }
        if (ms.isDeclare && fieldName != "") {
          let getterName = "get#" + fieldName;
          var found = false;
          for (let existing in ctVtable) {
            if (existing == getterName) { found = true; break; }
          }
          if (!found) { ctVtable.push(getterName); }
        }
      }
    }

    // 5. Register specialized methods
    var msIdx = -1;
    for (let ms in allMembers) {
      msIdx += 1;
      // Mixin-declared members get the mixin's private scope key so
      // their bodies resolve "#" fields to the mixin's namespaced
      // struct fields (WasmFunction.privateScopeKey).
      let msScope = allScopes[msIdx];

      if (ms is MethodDefinition) {
        if (ms.isAbstract) { continue; }
        let {typeParameters} = ms;
        if (typeParameters != null && typeParameters.length > 0) {
          continue;
        }
        let methName = memberKeyOf(sourceModel, ms.name as Node);
        // Mixin private methods register under the mixin's scope key
        // ("<scope>::#name") so a host's same-named private is a
        // different function; bodies from mixins carry the scope for
        // their own private accesses.
        let declNode = allDecls[msIdx];
        let memberScope = this.#memberScopeOf(ms, msScope, allDeclaringTypes[msIdx]);
        let regName = if (ms.isConstructor) {
          if (methName == "<constructor>") "<constructor>" else "<constructor>." + methName
        } else if (memberScope != "" && methName.length > 0 && methName.sliceBytes(0, 1) == "#") {
          `${memberScope}::${methName}`
        } else {
          methName
        };
        let regFn = this.registerClassMethod(ct, declNode, regName, ms as Node, false, false, null, allModels[msIdx]);
        regFn.declaringType = allDeclaringTypes[msIdx];
        applyMixinPrivateScope(regFn, ms as Node, memberScope);
      } else if (ms is AccessorDeclaration) {
        let declNode = allDecls[msIdx];
        let accName = this.#registeredAccessorName(
            memberKeyOf(sourceModel, ms.name as Node), allDeclaringTypes[msIdx]);
        let isPrivateAcc = accName.length > 0 && accName.sliceBytes(0, 1) == "#";
        if (ms.getter != null) {
          var getterRegName = "get#" + accName;
          if (isPrivateAcc && msScope != "") {
            getterRegName = `${msScope}::${getterRegName}`;
          }
          let regG = this.registerClassMethod(ct, declNode, getterRegName, ms as Node, false, false, null, allModels[msIdx]);
          regG.declaringType = allDeclaringTypes[msIdx];
          applyMixinPrivateScope(regG, ms as Node, msScope);
        }
        let {setter} = ms;
        if (setter != null) {
          var setterRegName = "set#" + accName;
          if (isPrivateAcc && msScope != "") {
            setterRegName = `${msScope}::${setterRegName}`;
          }
          let regS = this.registerClassMethod(ct, declNode, setterRegName, setter, false, false, null, allModels[msIdx]);
          regS.declaringType = allDeclaringTypes[msIdx];
          applyMixinPrivateScope(regS, setter, msScope);
        }
      } else if (ms is FieldDefinition) {
        if (ms.isStatic) { continue; }
        let declNode = allDecls[msIdx];
        let fieldName = memberKeyOf(sourceModel, ms.name as Node);
        if (fieldName != "" && !this.#isDecoratedField(ct, fieldName)) {
          if (!fieldName.startsWith("#")) {
            this.registerClassMethod(ct, declNode, "get#" + fieldName, null, true, false, fieldName, allModels[msIdx]);
            if (ms.mutability != null && ms.mutability == "var") {
              this.registerClassMethod(ct, declNode, "set#" + fieldName, null, false, true, fieldName, allModels[msIdx]);
            }
          } else {
            if (ms.setterName != null) {
              this.registerClassMethod(ct, declNode, "get#" + fieldName, null, true, false, fieldName, allModels[msIdx]);
            }
            if (ms.isAbstract) {
              this.registerClassMethod(ct, declNode, "get#" + fieldName, null, true, false, fieldName, allModels[msIdx]);
              if (ms.mutability != null && ms.mutability == "var") {
                this.registerClassMethod(ct, declNode, "set#" + fieldName, null, false, true, fieldName, allModels[msIdx]);
              }
            }
            if (ms.isDeclare) {
              this.registerClassMethod(ct, declNode, "get#" + fieldName, null, true, false, fieldName, allModels[msIdx]);
            }
          }
        }
      }
    }

    var hasExplicitCtor = false;
    if (classDecl != null) {
      let bodyNodes: GrowableArray<Node> | null = if (classDecl is ClassDeclaration) {
        classDecl.body
      } else if (classDecl is InterfaceDeclaration) {
        classDecl.body
      } else if (classDecl is MixinDeclaration) {
        classDecl.body
      } else {
        null
      };
      if (bodyNodes != null) {
        for (let member in bodyNodes) {
          if (member is MethodDefinition) {
            if (member.isConstructor) {
              hasExplicitCtor = true;
            }
          }
        }
      }
    }

    if (!hasExplicitCtor && !ct.isExtension && !ct.isMixinIntermediate && !containsErasedType(ct as Type)) {
      this.registerClassMethod(ct, classDecl, "<constructor>", null, false, false, null, sourceModel);
    }

    if (ct.derivesEquality) {
      let eqFunc = this.registerClassMethod(ct, classDecl, "==", null, false, false, null, sourceModel);
      eqFunc.isCaseClassEq = true;

      let hashFunc = this.registerClassMethod(ct, classDecl, "hashCode", null, false, false, null, sourceModel);
      hashFunc.isCaseClassHash = true;
    }
    if (synthesizedRelease(ct)) {
      // A class whose only release action is its fields: the checker
      // synthesized its release member (a resource's `:dispose`, a
      // `scoped T` class's `[release]`), and lowering emits the field
      // glue as its whole body.
      let dFunc = this.registerClassMethod(ct, classDecl, releaseMemberOf(ct), null, false, false, null, sourceModel);
      dFunc.isSyntheticRelease = true;
    }

    // Register implicit interface getters/setters for specialized classes
    let allIfaces = this.pass.cha.collectAllImplementedInterfaces(ct);
    for (let iface in allIfaces) {
      getInterfaceKey(iface);
      if (this.pass.isPackPairUsed(ct, iface)) {
        let keys = iface.members.keys();
        for (let key in keys) {
          let member = iface.members[key];
          if (member is FieldInfo) {
            let getterName = "get#" + key;
            getInterfaceKey(iface.genericSource ?? iface);
            let hasGetter = this.pass.wasm.classMethodMap.has(getClassMethodKey(cKey, getterName));
            if (!hasGetter) {
              this.registerClassMethod(ct, classDecl, getterName, null, true, false, key, sourceModel);
            }
            
            if (member.isMutable) {
              let setterName = "set#" + key;
              let hasSetter = this.pass.wasm.classMethodMap.has(getClassMethodKey(cKey, setterName));
              if (!hasSetter) {
                this.registerClassMethod(ct, classDecl, setterName, null, false, true, key, sourceModel);
              }
            }
          }
        }
      }
    }
    
    this.populateClassStructAndMethods(ct, classDecl, sourceModel);
  }

  registerSpecializedInterface(it: InterfaceType, ifaceDecl: InterfaceDeclaration | null, sourceModel: SemanticModel): void {
    if (!this.preRegisterInterfaceStruct(it)) {
      return;
    }
    this.finishSpecializedInterface(it, ifaceDecl, sourceModel);
  }

  preRegisterInterfaceStruct(it: InterfaceType): boolean {
    let iKey = getInterfaceKey(it);

    if (this.pass.wasm.interfaceStructs.has(iKey)) {
      return false;
    }

    // 1. Pre-register empty vtable and fat ptr structs
    let structName = iKey as String;
    let emptyVTableStruct = new WasmStruct(structName + "_VTable", new Array<WasmField>());
    this.pass.wasm.types.push(emptyVTableStruct);
    this.pass.wasm.interfaceVTableStructs[iKey] = emptyVTableStruct;

    let fatPtrFields = growable<WasmField>([
      new WasmField("instance", new ValTypeAnyRef(), false),
      new WasmField("vtable", new ValTypeRef(emptyVTableStruct), false),
    ]);
    let emptyStruct = new WasmStruct(structName + "_FatPtr", fatPtrFields);
    this.pass.wasm.types.push(emptyStruct);
    this.pass.wasm.interfaceStructs[iKey] = emptyStruct;

    // The vtable's slots are added for the members reached code calls
    // (ReachabilityAnalysis.#syncInterfaceSlots).
    this.pass.specializedInterfaces.push(it);
    return true;
  }

  finishSpecializedInterface(it: InterfaceType, ifaceDecl: InterfaceDeclaration | null, sourceModel: SemanticModel): void {
    let itParams = getInterfaceTypeParameters(it);

    // 2. Discover referenced types in members (fields, methods) — as
    // SIGNATURES: an interface method's function type is not a value,
    // and value-routing it minted a closure struct + impl signature
    // per member (22 of them from one Iterable-family interface).
    // Registration plumbing, so no name evidence (see
    // registerClassMethod).
    let savedSuppress = this.pass.suppressNameEvidence;
    this.pass.suppressNameEvidence = true;
    for (let pair in it.members) {
      let resolvedType = substituteTypeParamsInCodegen(this.pass.wasm, itParams, it.typeArguments, pair.value.type);
      this.pass.typeLowerer.discoverSignatureType(resolvedType, sourceModel);
      // Substitution leaves an overload list as declared, so each
      // overload's types are discovered separately.
      let overloads = interfaceMethodOverloads(this.pass.wasm, it, pair.key);
      if (overloads != null) {
        for (let overload in overloads) {
          this.pass.typeLowerer.discoverSignatureType(overload, sourceModel);
        }
      }
    }
    this.pass.suppressNameEvidence = savedSuppress;
  }

  /**
   * The class in `ct`'s super chain whose own declaration body
   * contains `node`, or null when none does (mixin members and
   * synthesized accessors have no declaring class in the chain).
   * `instantiateClassType` substitutes `superType` per hop, so the hop
   * that declares the node IS the declaring class's resolved
   * instantiation — the substitution context an inherited body is
   * lowered under.
   */
  declaringClassOf(ct: ClassType, node: Node): ClassType | null {
    var c: ClassType | null = ct;
    while (c != null) {
      let cc = c;
      if (cc.isMixinIntermediate) {
        c = cc.superType;
        continue;
      }
      let lookupId = (cc.genericSource ?? cc).symbolId;
      if (this.pass.classDecls.has(lookupId)) {
        let decl = this.pass.classDecls[lookupId];
        if (decl is ClassDeclaration) {
          for (let member in (decl as ClassDeclaration).body) {
            if (member === node) {
              return cc;
            }
            if (member is AccessorDeclaration &&
                (member as AccessorDeclaration).setter != null &&
                ((member as AccessorDeclaration).setter as Node) === node) {
              return cc;
            }
          }
        }
      }
      c = cc.superType;
    }
    return null;
  }

  registerClassMethod(
      cType: ClassType,
      cDecl: Node | null,
      methName: String,
      methodNode: Node | null,
      isSynthesizedGetter: boolean,
      isSynthesizedSetter: boolean,
      backingFieldName: String | null,
      model: SemanticModel,
      methodTypeArgs: Array<Type> | null = null): WasmFunction {

    // An inherited member registers under its declaring class's
    // resolved instantiation, not the instantiating class
    // (binary-size.md §16): the body can only mention type parameters
    // in scope at its declaration site, so the subclass-keyed copy is
    // byte-identical to the declaring class's. An override is a
    // different declaration — its declaring class IS the subclass —
    // and a subclass binding the base's generics differently resolves
    // to a different instantiation, so distinct copies survive exactly
    // where the key genuinely differs. Vtable slots and every lowering
    // lookup already walk the super chain, so they find the shared
    // body one hop later. Mixin-scoped names ("Scope::#x") stay
    // per-host: a mixin body's `this` maps to the host class.
    // Templates and erasures keep the old keying — nothing is emitted
    // at either.
    if (methodNode != null && !methName.contains("::") &&
        isConcrete(cType) && !containsErasedType(cType as Type)) {
      let declaring = this.declaringClassOf(cType, methodNode);
      if (declaring != null && declaring != cType) {
        let declId = ((declaring.genericSource ?? declaring)).symbolId;
        let dDecl = if (this.pass.classDecls.has(declId)) {
          this.pass.classDecls[declId]
        } else {
          cDecl
        };
        let dModel = if (this.pass.classModels.has(declId)) {
          this.pass.classModels[declId]
        } else {
          model
        };
        return this.registerClassMethod(declaring, dDecl, methName,
            methodNode, isSynthesizedGetter, isSynthesizedSetter,
            backingFieldName, dModel, methodTypeArgs);
      }
    }

    var isStatic = false;
    if (methodNode != null) {
      if (methodNode is MethodDefinition) {
        isStatic = methodNode.isStatic;
      } else if (methodNode is AccessorDeclaration) {
        isStatic = methodNode.isStatic;
      } else if (methodNode is FieldDefinition) {
        isStatic = methodNode.isStatic;
      } else if (methodNode is SetterInfo) {
        let parentNode = model.getParent(methodNode);
        if (parentNode is AccessorDeclaration) {
          isStatic = parentNode.isStatic;
        } else if (cDecl is ClassDeclaration) {
          for (let ms in cDecl.body) {
            if (ms is AccessorDeclaration && ms.setter === methodNode) {
              isStatic = ms.isStatic;
              break;
            }
          }
        } else if (cDecl is MixinDeclaration) {
          for (let ms in cDecl.body) {
            if (ms is AccessorDeclaration && ms.setter === methodNode) {
              isStatic = ms.isStatic;
              break;
            }
          }
        }
      }
    }
    if (!isStatic && methodNode == null && !isSynthesizedGetter && !isSynthesizedSetter &&
        cType != null && !cType.members.has(methName) && cType.staticMembers.has(methName)) {
      let mi = cType.staticMembers[methName];
      if (mi is MethodInfo) {
        isStatic = mi.isStatic;
      }
    }

    var realMethName = methName;
    var methodTypeNode: Type | null = null;
    var origMethodFt: FunctionType | null = null;
    if (cType != null) {
      let cTypeMembers = cType.memberTable(isStatic);
      if (methName == "<constructor>") {
        methodTypeNode = cType.constructorType;
        // A self-referential generic class instantiates ITSELF while its
        // own declaration is mid-check — before constructorType is filled
        // — and that cached instantiation keeps the null forever (the
        // instantiation caches copy constructorType by value). Derive the
        // signature from the generic source instead of registering a
        // bogus receiver-only constructor.
        if (methodTypeNode == null && cType.genericSource != null) {
          let gs = cType.genericSource as ClassType;
          let {constructorType} = gs;
          if (constructorType != null) {
            methodTypeNode = substituteTypeParamsInCodegen(this.pass.wasm, 
                gs.typeParameters, cType.typeArguments,
                constructorType);
          }
        }
      } else if (methName.startsWith("<constructor>.")) {
        let ctorName = methName.sliceBytes(14, methName.length);
        if (cType.constructors.has(ctorName)) {
          methodTypeNode = cType.constructors[ctorName];
        }
        if (methodTypeNode == null && cType.genericSource != null) {
          let gs = cType.genericSource as ClassType;
          if (gs.constructors.has(ctorName)) {
            let origCtor = gs.constructors[ctorName];
            methodTypeNode = substituteTypeParamsInCodegen(this.pass.wasm,
                gs.typeParameters, cType.typeArguments,
                origCtor);
          }
        }
      } else {
        var specificFuncType: FunctionType | null = null;
        var hasOverloads = false;
        if (methodNode is MethodDefinition) {
          if (cTypeMembers.has(methName)) {
            let mInfo = cTypeMembers[methName];
            if (mInfo.type is FunctionType) {
              let ft = mInfo.type as FunctionType;
              if (ft.overloads != null) {
                hasOverloads = true;
                specificFuncType = matchOverload(model, ft, methodNode);
              }
            }
          }
        }
        
        if (hasOverloads && specificFuncType != null) {
          methodTypeNode = specificFuncType;
          realMethName = methName + getSignatureKey(specificFuncType);
        } else {
          var baseName = methName;
          var sigKey = "";
          var specIdx = -1;
          if (methName.length >= 6) {
            for (var idx = 0; idx <= methName.length - 6; idx += 1) {
              if (methName.getByteAt(idx) == 95 && // '_'
                  methName.getByteAt(idx + 1) == 115 && // 's'
                  methName.getByteAt(idx + 2) == 112 && // 'p'
                  methName.getByteAt(idx + 3) == 101 && // 'e'
                  methName.getByteAt(idx + 4) == 99 && // 'c'
                  methName.getByteAt(idx + 5) == 95) { // '_'
                specIdx = idx;
                break;
              }
            }
          }
          if (specIdx >= 0) {
            baseName = methName.sliceBytes(0, specIdx);
          } else {
            var dollarIdx = -1;
            for (var idx = 0; idx < methName.length; idx += 1) {
              if (methName.getByteAt(idx) == 36) {
                dollarIdx = idx;
                break;
              }
            }
            if (dollarIdx > 0 && !methName.contains("get#") && !methName.contains("set#")) {
              baseName = methName.sliceBytes(0, dollarIdx);
              sigKey = methName.sliceBytes(dollarIdx, methName.length);
            }
          }

          var currClass: ClassType | null = cType;
          while (currClass != null && methodTypeNode == null) {
            let cc = currClass;
            let ccMembers = cc.memberTable(isStatic);
            if (baseName != methName) {
              if (ccMembers.has(baseName)) {
                let mInfo = ccMembers[baseName];
                if (mInfo.type is FunctionType) {
                  let ft = mInfo.type as FunctionType;
                  if (specIdx >= 0) {
                    methodTypeNode = ft;
                  } else if (getSignatureKey(ft) == sigKey) {
                    methodTypeNode = ft;
                  } else if (ft.overloads != null) {
                    let ovs = ft.overloads as GrowableArray<FunctionType>;
                    for (let ov in ovs) {
                      if (getSignatureKey(ov) == sigKey) {
                        methodTypeNode = ov;
                        break;
                      }
                    }
                  }
                }
              }
            } else if (ccMembers.has(methName)) {
              let mInfo = ccMembers[methName];
              // A METHOD registration must not take its signature from
              // a same-named FIELD: a distributed variant's case param
              // may shadow the sealed base's accessor method (docs()
              // over a docs field), and the walk must continue up to
              // the class that declares the method itself.
              let isMethodReg = methodNode != null &&
                  methodNode is MethodDefinition;
              if (!isMethodReg || mInfo is MethodInfo) {
                methodTypeNode = mInfo.type;
              }
            } else {
              for (let k in ccMembers.keys()) {
                if (k.endsWith("::" + methName)) {
                  let mInfo = ccMembers[k];
                  let isMethodReg = methodNode != null &&
                      methodNode is MethodDefinition;
                  if (!isMethodReg || mInfo is MethodInfo) {
                    methodTypeNode = mInfo.type;
                    break;
                  }
                }
              }
            }
            if (methodTypeNode == null) {
              currClass = cc.superType;
            }
          }
        }

        if (methodTypeNode == null) {
          var strippedMethName = methName;
          if (strippedMethName.contains("::")) {
            let parts = strippedMethName.split("::");
            strippedMethName = parts[parts.length - 1];
          }
          if (strippedMethName.contains(".")) {
            let parts = strippedMethName.split(".");
            strippedMethName = parts[parts.length - 1];
          }
          if (methName == "==" && !isStatic) {
            let eqParams = growable<Type>([cType]);
            methodTypeNode = new FunctionType(eqParams, new BooleanType());
          } else if (methName == "hashCode" && !isStatic) {
            methodTypeNode = new FunctionType(new Array<Type>(), new I32Type());
          } else if (strippedMethName.startsWith("get#")) {
            let fieldName = strippedMethName.sliceBytes(4, strippedMethName.length);
            var pType: Type | null = null;
            var curr: ClassType | null = cType;
            while (curr != null && pType == null) {
              let cc = curr;
              let ccMembers = cc.memberTable(isStatic);
              if (ccMembers.has(methName)) {
                let m = ccMembers[methName];
                if (m is MethodInfo && m.type is FunctionType) {
                  pType = (m.type as FunctionType).returnType;
                }
              }
              if (pType == null && ccMembers.has(strippedMethName)) {
                let m = ccMembers[strippedMethName];
                if (m is MethodInfo && m.type is FunctionType) {
                  pType = (m.type as FunctionType).returnType;
                }
              }
              if (pType == null && ccMembers.has(fieldName)) {
                let m = ccMembers[fieldName];
                if (m is FieldInfo) {
                  pType = m.type;
                } else if (m is MethodInfo && m.type is FunctionType) {
                  pType = (m.type as FunctionType).returnType;
                }
              }
              if (pType == null && ccMembers.has("#" + fieldName)) {
                let m = ccMembers["#" + fieldName];
                if (m is FieldInfo) {
                  pType = m.type;
                }
              }
              if (pType == null) {
                for (let k in ccMembers.keys()) {
                  if (k.endsWith("::" + methName) || k.endsWith("::" + strippedMethName) || k.endsWith("::" + fieldName) || k.endsWith("::#" + fieldName)) {
                    let m = ccMembers[k];
                    if (m is FieldInfo) {
                      pType = m.type;
                      break;
                    } else if (m is MethodInfo && m.type is FunctionType) {
                      pType = (m.type as FunctionType).returnType;
                      break;
                    }
                  }
                }
              }
              curr = cc.superType;
            }
            if (pType != null) {
              methodTypeNode = new FunctionType(new Array<Type>(), pType);
            }
          } else if (strippedMethName.startsWith("set#")) {
            let fieldName = strippedMethName.sliceBytes(4, strippedMethName.length);
            var pType: Type | null = null;
            var curr: ClassType | null = cType;
            while (curr != null && pType == null) {
              let cc = curr;
              let ccMembers = cc.memberTable(isStatic);
              if (ccMembers.has(methName)) {
                let m = ccMembers[methName];
                if (m is MethodInfo && m.type is FunctionType) {
                  let ft = m.type as FunctionType;
                  if (ft.parameters.length > 0) {
                    pType = ft.parameters[0];
                  } else {
                    pType = ft.returnType;
                  }
                }
              }
              if (pType == null && ccMembers.has(strippedMethName)) {
                let m = ccMembers[strippedMethName];
                if (m is MethodInfo && m.type is FunctionType) {
                  let ft = m.type as FunctionType;
                  if (ft.parameters.length > 0) {
                    pType = ft.parameters[0];
                  } else {
                    pType = ft.returnType;
                  }
                }
              }
              if (pType == null && ccMembers.has(fieldName)) {
                let m = ccMembers[fieldName];
                if (m is FieldInfo) {
                  pType = m.type;
                } else if (m is MethodInfo && m.type is FunctionType) {
                  let ft = m.type as FunctionType;
                  if (ft.parameters.length > 0) {
                    pType = ft.parameters[0];
                  } else {
                    pType = ft.returnType;
                  }
                }
              }
              if (pType == null && ccMembers.has("#" + fieldName)) {
                let m = ccMembers["#" + fieldName];
                if (m is FieldInfo) {
                  pType = m.type;
                }
              }
              if (pType == null) {
                for (let k in ccMembers.keys()) {
                  if (k.endsWith("::" + methName) || k.endsWith("::" + strippedMethName) || k.endsWith("::" + fieldName) || k.endsWith("::#" + fieldName)) {
                    let m = ccMembers[k];
                    if (m is FieldInfo) {
                      pType = m.type;
                      break;
                    } else if (m is MethodInfo && m.type is FunctionType) {
                      let ft = m.type as FunctionType;
                      if (ft.parameters.length > 0) {
                        pType = ft.parameters[0];
                      } else {
                        pType = ft.returnType;
                      }
                      break;
                    }
                  }
                }
              }
              curr = cc.superType;
            }
            if (pType != null) {
              let params = growable<Type>([pType]);
              methodTypeNode = new FunctionType(params, new VoidType());
            }
          }
        }
      }
    }

    if (methodTypeNode is FunctionType) {
      origMethodFt = methodTypeNode;
    }

    if (methodTypeNode != null && cType != null) {
      // Full class-context substitution, not just cType's own params:
      // a member found up the super chain (an inherited private
      // method, a synthesized accessor for an inherited field) has a
      // type written in terms of the DECLARING class's type
      // parameters, which are different symbols from cType's. The
      // body is lowered under the same context, so the signature must
      // substitute with it too or the two disagree about what T is.
      methodTypeNode = substituteTypeParamsInClassContext(this.pass.wasm, cType, methodTypeNode);
      if (methodTypeArgs != null && methodTypeNode is FunctionType) {
        let fType = methodTypeNode;
        let {typeParameters} = fType;
        if (typeParameters != null) {
          methodTypeNode = substituteTypeParamsInCodegen(this.pass.wasm, typeParameters, methodTypeArgs, methodTypeNode as Type);
        }
      }
    }
    if (methodTypeNode != null) {
      // A registration's signature is plumbing, not evidence: the
      // member may never be reached, and a reached body records its
      // own evidence when it is walked. Without the suppression, a
      // registered-but-unreached `slice(range)` kept four Range
      // structs in a module whose only code is an index loop.
      let savedSuppress = this.pass.suppressNameEvidence;
      this.pass.suppressNameEvidence = true;
      this.pass.typeLowerer.discoverSignatureType(methodTypeNode, model);
      this.pass.suppressNameEvidence = savedSuppress;
    }

    let params = new Array<ValType>();
    let returns = new Array<ValType>();

    let isCtor = isConstructorMethodName(methName);
    let rootClass = if (isCtor || isStatic) cType else getMemberRootClass(cType, methName);

    if (!isStatic) {
      // Constructors take no receiver: a non-extension constructor is a
      // FACTORY — it computes field values, allocates with one
      // struct.new, and returns the instance (non-nullable-refs.md,
      // Construction protocol). Extension constructors already had this
      // shape, returning the underlying value.
      if (!isCtor) {
        if (cType.isExtension && cType.onType != null) {
          params.push(typeToValType(this.pass.wasm, cType.onType as Type));
        } else {
          // The receiver is the declaring class's struct, non-null:
          // `this` is never null, and an override shares the slot's
          // signature by taking the same root receiver, so nullability
          // plays no part in dispatch.
          if (let (true, rootInfo) = this.pass.wasm.classInfos.get(getClassKey(rootClass))) {
            params.push(new ValTypeRef(rootInfo.structType));
          } else {
            params.push(new ValTypeStructRef());
          }
        }
      }
    }
    if (methodTypeNode is FunctionType) {
      // An `operator ==` below its slot's owner declares its parameter
      // over its own class, but shares the slot: it takes the owner's
      // parameter, and its body tests and casts `other` before running
      // (equality.md, "Overrides compare the same class").
      var paramTypes = methodTypeNode.parameters;
      if (methName == "==" && !isStatic && !isCtor && !cType.isExtension &&
          rootClass !== cType && rootClass.members.has("==")) {
        let rootMi = rootClass.members["=="];
        if (rootMi is MethodInfo && rootMi.type is FunctionType &&
            (rootMi.type as FunctionType).parameters.length == paramTypes.length) {
          paramTypes = (rootMi.type as FunctionType).parameters;
        }
      }
      for (let p in paramTypes) {
        mapParamTypeToWasmParams(this.pass.wasm, p, params);
      }
      if (!isCtor) {
        mapReturnTypeToWasmResults(this.pass.wasm, methodTypeNode.returnType, returns);
      } else if (cType.isExtension && cType.onType != null) {
        returns.push(typeToValType(this.pass.wasm, cType.onType as Type));
      } else {
        this.#pushCtorReturn(cType, returns);
      }
    } else if (!isCtor) {
      returns.push(new ValTypeI32());
    } else if (cType.isExtension && cType.onType != null) {
      returns.push(typeToValType(this.pass.wasm, cType.onType as Type));
    } else {
      this.#pushCtorReturn(cType, returns);
    }
    

    let sig = this.pass.wasm.getSignature(params, returns);
    let wasmFunc = new WasmFunction(sig, methodNode, model);
    if (origMethodFt != null && origMethodFt.typeParameters != null) {
      wasmFunc.typeParameters = origMethodFt.typeParameters;
      wasmFunc.typeArguments = methodTypeArgs;
    }

    var decs: GrowableArray<Decorator> | null = null;
    if (methodNode != null) {
      if (methodNode is MethodDefinition) {
        decs = methodNode.decorators;
      } else if (methodNode is AccessorDeclaration) {
        decs = methodNode.decorators;
      } else if (methodNode is FieldDefinition) {
        decs = methodNode.decorators;
      }
    } else if (backingFieldName != null && cDecl != null) {
      if (cDecl is ClassDeclaration) {
        for (let ms in cDecl.body) {
          if (ms is FieldDefinition) {
            let fName = memberKeyOf(model, ms.name as Node);
            if (fName == backingFieldName) {
              decs = ms.decorators;
            }
          }
        }
      }
    }
    
    if (decs != null) {
      for (let dec in decs) {
        if (dec.name == "intrinsic" && dec.args.length == 1) {
          wasmFunc.intrinsic = decoratorStringArg(dec, 0);
        }
      }
    }

    wasmFunc.isStatic = isStatic;
    let cName = getClassKey(cType) as String;
    wasmFunc.name = `${cName}.${realMethName}`;
    wasmFunc.methodName = realMethName;
    wasmFunc.classDecl = cDecl;
    
    wasmFunc.classType = cType;
    if (let (true, cInfo) = this.pass.wasm.classInfos.get(getClassKey(cType))) {
      wasmFunc.structType = cInfo.structType;
    }

    if (isSynthesizedGetter && backingFieldName != null) {
      let st = wasmFunc.structType;
      if (st != null) {
        var idx = -1;
        let lookupBackingName = if (backingFieldName.length > 0 && backingFieldName.sliceBytes(0, 1) == "#") {
          getClassPrivateFieldKey(getClassKey(cType), backingFieldName)
        } else {
          backingFieldName
        };
        for (var fi = 0; fi < st.fields.length; fi += 1) {
          if (st.fields[fi].name == lookupBackingName) {
            idx = fi;
          }
        }
        wasmFunc.getterStruct = st;
        wasmFunc.getterFieldIndex = idx;
      }
    } else if (isSynthesizedSetter && backingFieldName != null) {
      let st = wasmFunc.structType;
      if (st != null) {
        var idx = -1;
        let lookupBackingName = if (backingFieldName.length > 0 && backingFieldName.sliceBytes(0, 1) == "#") {
          getClassPrivateFieldKey(getClassKey(cType), backingFieldName)
        } else {
          backingFieldName
        };
        for (var fi = 0; fi < st.fields.length; fi += 1) {
          if (st.fields[fi].name == lookupBackingName) {
            idx = fi;
          }
        }
        wasmFunc.setterStruct = st;
        wasmFunc.setterFieldIndex = idx;
      }
    }

    let typeParameters = if (cType != null) cType.typeParameters else null;
    let isGenericTemplate = cType != null &&
                            typeParameters != null && 
                            typeParameters.length > 0 && 
                            (cType.typeArguments == null || !isConcrete(cType));

    let registeredKey = getClassMethodKey(getClassKey(cType), realMethName);
    let methodMap = this.pass.wasm.methodMap(isStatic);
    if (methodMap.has(registeredKey)) {
      let func = methodMap[registeredKey];
      if (func.node == null && methodNode != null) {
        func.node = methodNode;
      }
      if (func.classDecl == null && cDecl != null) {
        func.classDecl = cDecl;
      }
      // Registration is NOT reaching (binary-size.md §3a). The old
      // force-reach here — every registered method of an instantiated
      // class — was what the class vtable's all-methods slot list
      // required; with slots pruned to dispatchable methods, reaching
      // comes from the member referrers that name a method, and from
      // Pass 1.5 for the methods that genuinely hold slots.
      // CONSTRUCTORS keep it: they are never vtable-dispatched, and an
      // instantiated class's ctor must exist for its `new` sites
      // (instantiateClassType promotes ctors registered BEFORE
      // instantiation; this covers ones registered after). So do
      // MIXIN-SCOPED private members ("Scope::#name"): a mixin body
      // names them lexically, and no referrer machinery names them by
      // key, so nothing else reaches them. Lowering no longer falls
      // back to a host's same-named member when the registration is
      // missing — it bails — so dropping this force-reach would be a
      // loud compile failure rather than a silent wrong answer, but it
      // would still be a failure.
      let hasInst = this.pass.instantiatedSpecializedClasses.has(getClassKey(cType) as String);
      if (!isGenericTemplate && hasInst &&
          isConstructorMethodName(realMethName) &&
          this.pass.ctorDemandedGenerics.has(((cType.genericSource ?? cType)).symbolId)) {
        if (!this.pass.reachedFunctionsSet.has(func)) {
          this.#reachRegisteredMethod(func);
        }
      }
      return func;
    }

    let hasInstNew = this.pass.instantiatedSpecializedClasses.has(getClassKey(cType) as String);
    if (!isGenericTemplate && hasInstNew &&
        isConstructorMethodName(realMethName) &&
        this.pass.ctorDemandedGenerics.has(((cType.genericSource ?? cType)).symbolId)) {
      this.#reachRegisteredMethod(wasmFunc);
    }

    methodMap[registeredKey] = wasmFunc;
    let cKey = getClassKey(cType) as String;
    if (!this.pass.wasm.classMethods.has(cKey)) {
      this.pass.wasm.classMethods[cKey] = new Array<WasmFunction>();
    }
    this.pass.wasm.classMethods[cKey].push(wasmFunc);
    return wasmFunc;
  }

  /**
   * Force-reach a method a registration decided must exist (the class
   * is instantiated or an extension, so its vtable references the
   * function and it WILL be emitted). markFunctionReached is a no-op
   * when the ambient phase flag says "checkable", but registration
   * added the function to wasm.functions unconditionally — leaving an
   * emitted body whose dependencies were never traversed. Whether the
   * flag happened to be true here depended on which referrer processed
   * last, so the miss was graph-order dependent (String.split lowering
   * without its FixedArray<String> extension constructor registered,
   * in wit-parser's graph but not others).
   */
  #reachRegisteredMethod(func: WasmFunction): void {
    this.pass.wasm.addFunction(func);
    this.pass.forceReachFunction(func);
    if (func.methodName != null && isConstructorMethodName(func.methodName as String) &&
        func.classType != null) {
      this.#reachSuperConstructors(func);
    }
  }

  /**
   * A constructor drags its super chain's constructors with it: a
   * `: super(...)` lowers to a DIRECT call of the superclass's ctor,
   * resolved through `classMethodMap` — which `layout()` rebuilds from
   * REACHED functions only, so a super ctor that was merely registered
   * is gone by lowering (`zir unsupported: super constructor not
   * found`).
   *
   * This used to hold by accident: every class a subclass could name
   * was instantiated, so every super ctor was promoted on its own.
   * Instantiating on evidence broke the tie for the one shape where
   * the two halves disagree — a subclass whose class is instantiated
   * extending one whose class is not.
   *
   * Pending keys rather than direct reaches: the super's ctor may not
   * be registered yet when the subclass's is, and the settle drain
   * resolves by key after registration has finished.
   */
  #reachSuperConstructors(func: WasmFunction): void {
    if (func.classType == null) { return; }
    let ct = func.classType as ClassType;
    var curr = ct.superType;
    var currentFunc: WasmFunction | null = func;
    while (curr != null) {
      let superCt = curr;
      if (superCt.isMixinIntermediate) {
        curr = superCt.superType;
        continue;
      }
      var superCtorMeth = "<constructor>";
      if (currentFunc != null && currentFunc.node is MethodDefinition) {
        let md = currentFunc.node as MethodDefinition;
        if (md.superInitializer != null) {
          let si = md.superInitializer as SuperInitializer;
          if (si.constructorName != null) {
            superCtorMeth = "<constructor>." +
                getNodeMemberName(currentFunc.model, si.constructorName as Node);
          }
        }
      }
      let superKey = getClassMethodKey(getClassKey(superCt), superCtorMeth);
      this.pass.notePendingMemberReach(superKey);
      if (let (true, nextFunc) = this.pass.wasm.classMethodMap.get(superKey)) {
        currentFunc = nextFunc;
      } else {
        currentFunc = null;
      }
      curr = superCt.superType;
    }
  }

  /**
   * The name a written accessor registers under on its host. A decorator's
   * subject accessor is written against the placeholder name and registered
   * under the decorated field's name (ClassType.decoratorSubjectName on the
   * application's intermediate class); every other accessor keeps its own.
   */
  #registeredAccessorName(accName: String, declaringType: ClassType | null): String {
    if (declaringType != null && declaringType.decoratorSubjectName != null &&
        (declaringType.decoratorSubjectName as String) == accName) {
      return declaringType.decoratorFieldName as String;
    }
    return accName;
  }

  /**
   * The scope key a member body's private names register and resolve
   * under: the declaring intermediate's key, except a decorator's
   * `shared` method, which lives under the declaration's shared key so
   * every application in the class calls the one copy.
   */
  #memberScopeOf(ms: MethodDefinition, msScope: String, declaringType: ClassType | null): String {
    if (ms.isShared && declaringType != null && declaringType.decoratorSharedScopeKey != null) {
      return declaringType.decoratorSharedScopeKey as String;
    }
    return msScope;
  }

  /**
   * Whether `fieldName` is a decorated field of `ct`'s own body. Such a
   * field has no storage and no synthesized accessors of its own: the
   * decorator's accessor is registered under its name instead.
   */
  #isDecoratedField(ct: ClassType, fieldName: String): boolean {
    let decorated = ct.decoratedFields;
    return decorated != null && decorated.has(fieldName);
  }

  populateClassStructAndMethods(ct: ClassType, cd: Node | null, sourceModel: SemanticModel): void {
    let cKey = getClassKey(ct);
    if (!this.pass.wasm.classInfos.has(cKey)) {
      this.registerSpecializedClass(ct, cd, sourceModel);
    }
    let ctVtable = this.pass.wasm.classVtable(cKey);
    var vstOpt: WasmStruct | null = null;
    var stOpt: WasmStruct | null = null;
    if (let (true, info) = this.pass.wasm.classInfos.get(cKey)) {
      stOpt = info.structType;
      vstOpt = info.vtableStructType;
    }
    if (stOpt == null || vstOpt == null) {
      throw new Error("Class struct or vtable struct not found for class: " + ct.name);
    }
    let st = stOpt;
    let vst = vstOpt;
    if (st.fields.length > 0) {
      return;
    }
    
    let vtableSet = new Set<String>();
    for (let existing in ctVtable) {
      vtableSet.add(existing);
    }

    let {superType} = ct;
    if (superType != null) {
      let superCt = superType;
      let superLookupId = (superCt.genericSource ?? superCt).symbolId;
      let superDecl: Node | null = if (this.pass.classDecls.has(superLookupId)) this.pass.classDecls[superLookupId] else null;
      let superModel = this.pass.getClassModel(superCt);
      this.populateClassStructAndMethods(superCt, superDecl, superModel);

      let superVtable = this.pass.wasm.classVtable(getClassKey(superCt));
      for (let methName in superVtable) {
        if (!vtableSet.has(methName)) {
          ctVtable.push(methName);
          vtableSet.add(methName);
        }
      }
    }

    if (ct.derivesEquality) {
      if (!ct.members.has("==")) {
        let eqParams = growable<Type>([ct]);
        let eqNames = growable<String>(["other"]);
        ct.members["=="] = new MethodInfo(new FunctionType(eqParams, new BooleanType(), new FunctionDeclInfo(eqNames)), false, false, false, false);
      }
      if (!vtableSet.has("==")) {
        ctVtable.push("==");
        vtableSet.add("==");
      }

      if (!ct.members.has("hashCode")) {
        ct.members["hashCode"] = new MethodInfo(new FunctionType(new Array<Type>(), new I32Type()), false, false, false, false);
      }
      if (!vtableSet.has("hashCode")) {
        ctVtable.push("hashCode");
        vtableSet.add("hashCode");
      }
    }

    // A mixin application's intermediate class gets no methods of its own,
    // with or without a superclass: each class that applies the mixin
    // compiles its own copies (the mixin chain walk below), so a mixin
    // body's `this` is always a class that implements the mixin's `on`
    // interfaces.
    let cdDecl = if (cd is ClassDeclaration) cd else null;
    let isErasedCt = containsErasedType(ct as Type);
    if (cdDecl != null && !isErasedCt) {
      let allMembers = new Array<Node>();
      let allScopes = new Array<String>();
      let allModels = new Array<SemanticModel>();
      let allDecls = new Array<Node>();
      let allDeclaringTypes = new Array<ClassType | null>();
      if (cdDecl != null) {
        var mixinSup = ct.superType;
        let mixinChain = new Array<ClassType>();
        while (mixinSup != null && mixinSup.isMixinIntermediate) {
          mixinChain.push(mixinSup);
          mixinSup = mixinSup.superType;
        }
        var mci = mixinChain.length - 1;
        while (mci >= 0) {
          let mSup = mixinChain[mci];
          let mLookupId = (mSup.genericSource ?? mSup).symbolId;
          if (this.pass.classDecls.has(mLookupId)) {
            let mDecl = this.pass.classDecls[mLookupId];
            if (mDecl is MixinDeclaration) {
              for (let composed in mSup.mixins) {
                let compLookupId = (composed.genericSource ?? composed).symbolId;
                if (this.pass.classDecls.has(compLookupId)) {
                  let cDecl = this.pass.classDecls[compLookupId];
                  if (cDecl is MixinDeclaration) {
                    let compModel = if (this.pass.classModels.has(compLookupId)) this.pass.classModels[compLookupId] else sourceModel;
                    for (let ms in (cDecl as MixinDeclaration).body) {
                      allMembers.push(ms);
                      allScopes.push(composed.privateScopeKey ?? "");
                      allModels.push(compModel);
                      allDecls.push(cDecl);
                      allDeclaringTypes.push(mSup);
                    }
                  }
                }
              }
              let mModel = if (this.pass.classModels.has(mLookupId)) this.pass.classModels[mLookupId] else sourceModel;
              for (let ms in (mDecl as MixinDeclaration).body) {
                allMembers.push(ms);
                allScopes.push(mSup.privateScopeKey ?? "");
                allModels.push(mModel);
                allDecls.push(mDecl);
                allDeclaringTypes.push(mSup);
              }
            }
          }
          mci -= 1;
        }
        for (let ms in cdDecl.body) {
          allMembers.push(ms);
          allScopes.push("");
          allModels.push(sourceModel);
          allDecls.push(cdDecl);
          allDeclaringTypes.push(null);
        }
      }

      var vtableMethIdx = 0;
      while (vtableMethIdx < allMembers.length) {
        let ms = allMembers[vtableMethIdx];
        let msScope = allScopes[vtableMethIdx];
        let msIdx = vtableMethIdx;
        vtableMethIdx += 1;
        if (ms is MethodDefinition) {
          let {typeParameters} = ms;
          if (typeParameters != null && typeParameters.length > 0) {
            continue;
          }
          let methName = memberKeyOf(sourceModel, ms.name as Node);
          if (methName != "") {
            var vtableMethName = methName;
            let msMembers = ct.memberTable(ms.isStatic);
            if (msMembers.has(methName)) {
              let mInfo = msMembers[methName];
              if (mInfo.type is FunctionType) {
                let ft = mInfo.type as FunctionType;
                let specificType = matchOverload(allModels[msIdx], ft, ms);
                if (specificType != null) {
                  vtableMethName = methName + getSignatureKey(specificType);
                }
              }
            }

            // Privates: no vtable slot (never virtual); mixin
            // privates register under the mixin's scope key.
            let isPrivateMeth = methName.length > 0 && methName.sliceBytes(0, 1) == "#";
            // See above: a generic method has no single body to hold.
            let isGenericMeth = ms.typeParameters != null &&
                (ms.typeParameters as GrowableArray<TypeParameter>).length > 0;
            if (!ms.isStatic && !vtableSet.has(vtableMethName) && !ms.isConstructor && methName != "<constructor>" && !isPrivateMeth && !isGenericMeth && !ct.isExtension) {
              ctVtable.push(vtableMethName);
              vtableSet.add(vtableMethName);
            }
            // An abstract method has a slot, so a call through this
            // class dispatches to the subclass's override, and no body:
            // the slot is filled with a stub until a subclass's
            // implementation replaces it.
            if (ms.isAbstract) { continue; }
            let declNode = allDecls[msIdx];
            let memberScope = this.#memberScopeOf(ms, msScope, allDeclaringTypes[msIdx]);
            let regName = if (ms.isConstructor) {
              if (methName == "<constructor>") "<constructor>" else "<constructor>." + methName
            } else if (memberScope != "" && methName.length > 0 && methName.sliceBytes(0, 1) == "#") {
              `${memberScope}::${methName}`
            } else {
              methName
            };
            let regFn = this.registerClassMethod(ct, declNode, regName, ms as Node, false, false, null, allModels[msIdx]);
            regFn.declaringType = allDeclaringTypes[msIdx];
            applyMixinPrivateScope(regFn, ms as Node, memberScope);
          }
        } else if (ms is AccessorDeclaration) {
          let declNode = allDecls[msIdx];
          let accName = this.#registeredAccessorName(
              memberKeyOf(sourceModel, ms.name as Node), allDeclaringTypes[msIdx]);
          let isPrivateAcc = accName.length > 0 && accName.sliceBytes(0, 1) == "#";
          if (ms.getter != null) {
            var getterRegName = "get#" + accName;
            if (isPrivateAcc && msScope != "") {
              getterRegName = `${msScope}::${getterRegName}`;
            }
            let regG = this.registerClassMethod(ct, declNode, getterRegName, ms as Node, false, false, null, allModels[msIdx]);
            regG.declaringType = allDeclaringTypes[msIdx];
            applyMixinPrivateScope(regG, ms as Node, msScope);
          }
          let {setter} = ms;
          if (setter != null) {
            var setterRegName = "set#" + accName;
            if (isPrivateAcc && msScope != "") {
              setterRegName = `${msScope}::${setterRegName}`;
            }
            let regS = this.registerClassMethod(ct, declNode, setterRegName, setter, false, false, null, allModels[msIdx]);
            regS.declaringType = allDeclaringTypes[msIdx];
            applyMixinPrivateScope(regS, setter, msScope);
          }
        } else if (ms is FieldDefinition) {
          if (ms.isStatic) { continue; }
          let declNode = allDecls[msIdx];
          let fieldName = memberKeyOf(sourceModel, ms.name as Node);
          if (fieldName != "" && !this.#isDecoratedField(ct, fieldName)) {
            if (!fieldName.startsWith("#")) {
              let getterName = "get#" + fieldName;
              if (!vtableSet.has(getterName) && !ct.isExtension) {
                ctVtable.push(getterName);
                vtableSet.add(getterName);
              }
              this.registerClassMethod(ct, declNode, getterName, null, true, false, fieldName, allModels[msIdx]);
              if (ms.mutability != null && ms.mutability == "var") {
                let setterName = "set#" + fieldName;
                if (!vtableSet.has(setterName) && !ct.isExtension) {
                  ctVtable.push(setterName);
                  vtableSet.add(setterName);
                }
                this.registerClassMethod(ct, declNode, setterName, null, false, true, fieldName, allModels[msIdx]);
              }
            } else {
              if (ms.setterName != null) {
                let getterName = "get#" + fieldName;
                if (!vtableSet.has(getterName) && !ct.isExtension) {
                  ctVtable.push(getterName);
                  vtableSet.add(getterName);
                }
                this.registerClassMethod(ct, declNode, getterName, null, true, false, fieldName, allModels[msIdx]);
              }
              if (ms.isAbstract) {
                let getterName = "get#" + fieldName;
                if (!vtableSet.has(getterName) && !ct.isExtension) {
                  ctVtable.push(getterName);
                  vtableSet.add(getterName);
                }
                this.registerClassMethod(ct, declNode, getterName, null, true, false, fieldName, allModels[msIdx]);
                if (ms.mutability != null && ms.mutability == "var") {
                  let setterName = "set#" + fieldName;
                  if (!vtableSet.has(setterName) && !ct.isExtension) {
                    ctVtable.push(setterName);
                    vtableSet.add(setterName);
                  }
                  this.registerClassMethod(ct, declNode, setterName, null, false, true, fieldName, allModels[msIdx]);
                }
              }
              if (ms.isDeclare) {
                let getterName = "get#" + fieldName;
                if (!vtableSet.has(getterName) && !ct.isExtension) {
                  ctVtable.push(getterName);
                  vtableSet.add(getterName);
                }
                this.registerClassMethod(ct, declNode, getterName, null, true, false, fieldName, allModels[msIdx]);
              }
            }
          }
        }
      }
    }

    if ((cdDecl != null || ct.isCaseClass || (cd is SealedVariant)) && !ct.isExtension && !isErasedCt && !ct.isMixinIntermediate) {
      if (ct.constructorType != null || ct.constructors.size == 0) {
        let wasmFunc = this.registerClassMethod(ct, cd, "<constructor>", null, false, false, null, sourceModel);
        if (wasmFunc.classDecl == null) {
          wasmFunc.classDecl = cd;
        }
        if (wasmFunc.structType == null) {
          wasmFunc.structType = st;
        }
        // Re-derive the factory's return at the now-registered struct;
        // the first registration may have preceded it and fallen back to
        // structref.
        let returns = growable<ValType>([new ValTypeRef(st)]);
        let sig = this.pass.wasm.getSignature(
            wasmFunc.signature.params, returns);
        wasmFunc.signature = sig;
        this.pass.markTypeReached(sig);
      }
      for (let entry in ct.constructors) {
        if (entry.key == "<constructor>") {
          continue;
        }
        let ctorMethName = "<constructor>." + entry.key;
        let cKey = getClassKey(ct);
        let ctorKey = getClassMethodKey(cKey, ctorMethName);
        if (let (true, ctorFn) = this.pass.wasm.classMethodMap.get(ctorKey)) {
          if (ctorFn.classDecl == null) {
            ctorFn.classDecl = cd;
          }
          if (ctorFn.structType == null) {
            ctorFn.structType = st;
          }
          let returns = growable<ValType>([new ValTypeRef(st)]);
          let sig = this.pass.wasm.getSignature(
              ctorFn.signature.params, returns);
          ctorFn.signature = sig;
          this.pass.markTypeReached(sig);
        }
      }
      if (ct.derivesEquality) {
        let eqFunc = this.registerClassMethod(ct, cd, "==", null, false, false, null, sourceModel);
        eqFunc.isCaseClassEq = true;
        let hashFunc = this.registerClassMethod(ct, cd, "hashCode", null, false, false, null, sourceModel);
        hashFunc.isCaseClassHash = true;
      }
      if (synthesizedRelease(ct)) {
        let dFunc = this.registerClassMethod(ct, cd, releaseMemberOf(ct), null, false, false, null, sourceModel);
        dFunc.isSyntheticRelease = true;
      }
    }

    if (vst.fields.length == 0) {
      // Every slot name is laid out here, and the ones nothing
      // dispatches through are dropped from the whole hierarchy once
      // reachability settles (ReachabilityAnalysis.#pruneUndispatchedSlots).
      // Deciding per class at this point would be too early: layout runs
      // partway through the walk, before most call sites are seen.
      for (let methName in ctVtable) {
        vst.fields.push(new WasmField(methName, new ValTypeFuncRef(), false));
      }
    }

    let fields = new Array<WasmField>();
    var hasPhysicalSuper = false;
    if (ct.superType != null) {
      let superCt = ct.superType as ClassType;
      if (!superCt.isExtension) {
        hasPhysicalSuper = true;
        let superKey = getClassKey(superCt);
        if (let (true, superInfo) = this.pass.wasm.classInfos.get(superKey)) {
          let superSt = superInfo.structType;
          for (let f in superSt.fields) {
            fields.push(f);
          }
        }
      }
    }
    if (!hasPhysicalSuper) {
      var rootVst = vst;
      while (rootVst.superStruct != null) {
        rootVst = rootVst.superStruct as WasmStruct;
      }
      // Immutable: the constructor passes it to struct.new and nothing
      // writes it after, and an immutable field may refine its type in
      // a subtype, which is what lets a root struct extend `Object`
      // (ReachabilityAnalysis's #layoutTypeTests).
      fields.push(new WasmField("<vtable>", new ValTypeRefNull(rootVst), false));
    }

    let ctParams = getClassTypeParameters(ct);
    for (let pair in ct.members) {
      if (pair.value is MethodInfo) {
        continue;
      }
      if (pair.value.isAbstract) {
        continue;
      }
      if (pair.value is FieldInfo && (pair.value as FieldInfo).isStatic) {
        continue;
      }
      var isInherited = false;
      if (ct.superType != null) {
        let superKey = getClassKey(ct.superType as ClassType);
        if (let (true, superInfo) = this.pass.wasm.classInfos.get(superKey)) {
          let superSt = superInfo.structType;
          for (let sf in superSt.fields) {
            if (sf.name == pair.key) {
              isInherited = true;
            }
          }
        }
      }
      if (!isInherited) {
        let fName = if (pair.key.contains("::#")) {
          // Mixin private fields arrive pre-scoped from the checker
          // ("<mixinScopeKey>::#name") — the member key IS the field
          // name, shared by every application of the mixin.
          pair.key
        } else if (pair.key.length > 0 && pair.key.sliceBytes(0, 1) == "#") {
          getClassPrivateFieldKey(cKey, pair.key)
        } else {
          pair.key
        };
        let resolvedType = substituteTypeParamsInCodegen(this.pass.wasm, ctParams, ct.typeArguments, pair.value.type);
        let valType = typeToValType(this.pass.wasm, resolvedType);
        if (valType is ValTypeVoid) {
          // A zero-width field (`Box<void>.value`) holds nothing, so it
          // gets no storage. Reads of it lower to no value and writes
          // to it lower to just their right-hand side's effects.
          continue;
        }
        // Precise field types (non-nullable-refs.md): `T` stays
        // `(ref $T)` and only `T | null` is nullable, and `let` fields
        // are immutable — single-shot construction supplies every
        // field's value to struct.new, so nothing needs the
        // defaultable/mutable widening anymore.
        let fieldIsMutable = if (pair.value is FieldInfo) {
          (pair.value as FieldInfo).isMutable
        } else {
          true
        };
        let wf = new WasmField(fName, valType, fieldIsMutable);
        // `structref` for a class-typed field means the class had no
        // registration yet — discovery may still produce one, and then
        // its method signatures would be precise while this field is
        // erased. Remember the bake so it can be re-resolved once
        // discovery settles.
        if (valType is ValTypeStructRef && resolvedType is ClassType) {
          this.#erasedFieldBakes.push(new ErasedFieldBake(wf, resolvedType));
        }
        fields.push(wf);
      }
    }
    for (let f in fields) {
      st.fields.push(f);
    }

  }

  /**
   * The factory's return type: the instance at its precise struct
   * type. A registration that precedes the struct falls back to
   * structref; the constructor patch-up in populateClassStructAndMethods
   * re-derives the signature once the struct exists — the same
   * two-step the receiver parameter used.
   */
  #pushCtorReturn(cType: ClassType, returns: GrowableArray<ValType>): void {
    if (let (true, cInfo) = this.pass.wasm.classInfos.get(getClassKey(cType))) {
      returns.push(new ValTypeRef(cInfo.structType));
    } else {
      returns.push(new ValTypeStructRef());
    }
  }

  /**
   * The value and body phases of superclass constructors
   * (non-nullable-refs.md, Construction protocol). A subclass factory
   * drives its ancestor chain through `<ctor-init>` — declared
   * constructor params in, own field values (struct order, defaults
   * filled) plus the evaluated super() arguments out — and
   * `<ctor-body>`, the written body run on the allocated instance.
   * Minted after the discovery fixpoint, when every constructor
   * signature and struct is final; the ancestors' ASTs were walked
   * when their factories were reached, so the phases introduce no new
   * discovery.
   */
  mintConstructorPhases(): void {
    // Snapshot the reached constructors: minting appends functions.
    let ctors = new Array<WasmFunction>();
    for (let f in this.pass.wasm.functions) {
      if (f.methodName != null &&
          isConstructorMethodName(f.methodName as String) &&
          f.classType != null &&
          !(f.classType as ClassType).isExtension) {
        ctors.push(f);
      }
    }
    for (let f in ctors) {
      var currFn = f;
      var anc = (f.classType as ClassType).superType;
      while (anc != null) {
        let ancCt = anc;
        if (ancCt.isMixinIntermediate) {
          anc = ancCt.superType;
          continue;
        }
        var superCtorMeth = '<constructor>';
        if (currFn.node is MethodDefinition) {
          let md = currFn.node as MethodDefinition;
          if (md.superInitializer != null) {
            let si = md.superInitializer as SuperInitializer;
            if (si.constructorName != null) {
              superCtorMeth = '<constructor>.' +
                  getNodeMemberName(currFn.model, si.constructorName as Node);
            }
          }
        }
        let factoryKey = getClassMethodKey(getClassKey(ancCt), superCtorMeth);
        if (let (true, ancFactory) =
            this.pass.wasm.classMethodMap.get(factoryKey)) {
          this.#mintPhasesFor(ancCt, ancFactory);
          currFn = ancFactory;
        }
        anc = ancCt.superType;
      }
    }
  }

  #mintPhasesFor(cType: ClassType, factory: WasmFunction): void {
    let cKey = getClassKey(cType);
    let fMeth = factory.methodName as String;
    let suffix = if (fMeth == '<constructor>') "" else fMeth.sliceBytes(14, fMeth.length);
    let initMethName = if (suffix == "") '<ctor-init>' else '<ctor-init>.' + suffix;
    let bodyMethName = if (suffix == "") '<ctor-body>' else '<ctor-body>.' + suffix;
    let initKey = getClassMethodKey(cKey, initMethName);
    if (this.pass.wasm.classMethodMap.has(initKey)) {
      return;
    }
    let st = factory.structType;
    if (st == null) {
      throw new Error('constructor phases without a struct: ' +
          (cKey as String));
    }
    let structType = st;
    // Own fields start after the inherited prefix; a root class's
    // field 0 is the synthetic <vtable>.
    var ownStart = 1;
    var s = structType.superStruct;
    while (s != null) {
      let curr = s;
      if (curr.classType != null && (curr.classType as ClassType).isMixinIntermediate) {
        s = curr.superStruct;
        continue;
      }
      ownStart = curr.fields.length;
      break;
    }
    let initReturns = new Array<ValType>();
    var fi = ownStart;
    while (fi < structType.fields.length) {
      initReturns.push(structType.fields[fi].type);
      fi += 1;
    }
    var superCt = cType.superType;
    while (superCt != null && (superCt as ClassType).isMixinIntermediate) {
      superCt = (superCt as ClassType).superType;
    }
    if (superCt != null) {
      var superCtorMeth = '<constructor>';
      if (factory.node is MethodDefinition) {
        let md = factory.node as MethodDefinition;
        if (md.superInitializer != null) {
          let si = md.superInitializer as SuperInitializer;
          if (si.constructorName != null) {
            superCtorMeth = '<constructor>.' +
                  getNodeMemberName(factory.model, si.constructorName as Node);
          }
        }
      }
      let superKey = getClassMethodKey(
          getClassKey(superCt as ClassType), superCtorMeth);
      if (let (true, superFactory) =
          this.pass.wasm.classMethodMap.get(superKey)) {
        for (let p in superFactory.signature.params) {
          initReturns.push(p);
        }
      }
    }
    let initSig = this.pass.wasm.getSignature(
        factory.signature.params, initReturns);
    let initFn = new WasmFunction(initSig, factory.node, factory.model);
    initFn.name = `${cKey as String}.${initMethName}`;
    initFn.methodName = initMethName;
    initFn.classType = cType;
    initFn.classDecl = factory.classDecl;
    initFn.structType = structType;
    this.pass.wasm.classMethodMap[initKey] = initFn;
    this.pass.wasm.addFunction(initFn);
    this.pass.markFunctionReached(initFn);

    if (ctorHasRunnableBody(factory)) {
      let bodyParams = growable<ValType>([new ValTypeRef(structType)]);
      for (let p in factory.signature.params) {
        bodyParams.push(p);
      }
      let bodySig = this.pass.wasm.getSignature(
          bodyParams, new Array<ValType>());
      let bodyFn = new WasmFunction(bodySig, factory.node, factory.model);
      bodyFn.name = `${cKey as String}.${bodyMethName}`;
      bodyFn.methodName = bodyMethName;
      bodyFn.classType = cType;
      bodyFn.classDecl = factory.classDecl;
      bodyFn.structType = structType;
      this.pass.wasm.classMethodMap[getClassMethodKey(cKey, bodyMethName)] =
          bodyFn;
      this.pass.wasm.addFunction(bodyFn);
      this.pass.markFunctionReached(bodyFn);
    }
  }

  instantiateInterfaceConstructor(it: InterfaceType, ctorName: String, methodNode: Node, model: SemanticModel): WasmFunction {
    let source = it.genericSource ?? it;
    let targsOpt = it.typeArguments;
    let typeArgs = if (targsOpt != null) targsOpt else new Array<Type>();
    let baseName = getInterfaceConstructorBaseName(it, ctorName);
    let specKey = getSpecializedFunctionKey(baseName, typeArgs);
    if (let (true, existing) = this.pass.wasm.specializedFunctions.get(specKey)) {
      this.pass.markFunctionReached(existing);
      return existing;
    }
    // The factory returns the interface value: its fat-pointer struct
    // must exist before the signature is built.
    this.registerSpecializedInterface(it, this.pass.interfaceDecls[source.symbolId], model);

    // The constructor's checked type is written at the interface's own
    // type parameters (registerInterfaceConstructor); substitute the
    // instantiation's arguments into the signature, as
    // instantiateGenericFunction does for a generic function.
    // The constructor's own parameters: the interface's, or a restatement
    // of them with bounds (checker: registerInterfaceConstructor).
    let ft = model.getNodeType(methodNode) as FunctionType;
    let typeParams = ft.typeParameters;
    let concreteParams = new Array<ValType>();
    let concreteReturns = new Array<ValType>();
    // The substituted types must be discovered before they are mapped:
    // a class the program has not instantiated yet maps to a bare
    // structref, and the signature would keep it. A global whose
    // initializer is the first `new Array<X>()` reaches here from the
    // queue walk before anything has instantiated GrowableArray<X>.
    let typeLowerer = this.pass.typeLowerer;
    for (let p in ft.parameters) {
      let subType = if (typeParams != null) {
        substituteTypeParamsInCodegen(this.pass.wasm, typeParams, typeArgs, p)
      } else {
        p
      };
      typeLowerer.discoverType(subType, model);
      mapParamTypeToWasmParams(this.pass.wasm, subType, concreteParams);
    }
    let subReturn = if (typeParams != null) {
      substituteTypeParamsInCodegen(this.pass.wasm, typeParams, typeArgs, ft.returnType)
    } else {
      ft.returnType
    };
    typeLowerer.discoverType(subReturn, model);
    mapReturnTypeToWasmResults(this.pass.wasm, subReturn, concreteReturns);

    let sig = this.pass.wasm.getSignature(concreteParams, concreteReturns);
    let wasmFunc = new WasmFunction(sig, methodNode, model);
    if (typeParams != null) {
      wasmFunc.typeParameters = typeParams;
      wasmFunc.typeArguments = typeArgs;
    }
    wasmFunc.name = getSpecializedName(baseName, typeArgs);
    this.pass.wasm.specializedFunctions[specKey] = wasmFunc;
    this.pass.wasm.addFunction(wasmFunc);
    // markFunctionReached queues a node referrer for the body with
    // this specialization's type arguments (see instantiateGenericFunction
    // for why these entries are needed first).
    this.pass.nodeIdToNode[methodNode.id as i32] = methodNode;
    this.pass.nodeIdToModel[methodNode.id as i32] = model;
    this.pass.markFunctionReached(wasmFunc);
    return wasmFunc;
  }

  instantiateGenericFunction(symId: SymbolId, typeArgs: Array<Type>): WasmFunction {
    let funcExpr = this.pass.wasm.genericFunctions[symId];
    let model = this.pass.wasm.genericFunctionModels[symId];

    // The signature below is read off the arrow's checked type, which
    // a module whose bodies waited to be reached has not written yet.
    let deferred = model.deferredBodies;
    if (deferred != null) {
      deferred.checkGlobalBody(symId);
    }

    // Determine target name
    var originalName = "";
    let parentNode = model.getParent(funcExpr);
    if (parentNode is VariableDeclaration) {
      if (parentNode.pattern is IdentifierPattern) {
        originalName = (parentNode.pattern as IdentifierPattern).name;
      }
    } else if (parentNode is FunctionDeclaration) {
      originalName = parentNode.name.name;
    }
    if (originalName == "") {
      originalName = "generic_func";
    }
    
    let specKey = getSpecializedFunctionKey(originalName, typeArgs);
    let specName = getSpecializedName(originalName, typeArgs);
    if (this.pass.wasm.specializedFunctions.has(specKey)) {
      let func = this.pass.wasm.specializedFunctions[specKey];
      this.pass.markFunctionReached(func);
      return func;
    }
    
    // Resolve the original generic FunctionType
    let funcTypeNode = model.getNodeType(funcExpr) as FunctionType;
    let typeParams = funcTypeNode.typeParameters;
    
    // Substitute typeParams with typeArgs in the function signature
    let concreteParams = new Array<ValType>();
    let concreteReturns = new Array<ValType>();
    
    for (let p in funcTypeNode.parameters) {
      let subType = substituteTypeParamsInCodegen(this.pass.wasm, typeParams, typeArgs, p);
      mapParamTypeToWasmParams(this.pass.wasm, subType, concreteParams);
    }
    
    let subReturn = substituteTypeParamsInCodegen(this.pass.wasm, typeParams, typeArgs, funcTypeNode.returnType);
    mapReturnTypeToWasmResults(this.pass.wasm, subReturn, concreteReturns);
    
    let sig = this.pass.wasm.getSignature(concreteParams, concreteReturns);
    let wasmFunc = new WasmFunction(sig, funcExpr, model);
    
    // Track type parameters and arguments for codegen context
    wasmFunc.typeParameters = typeParams;
    wasmFunc.typeArguments = typeArgs;
    wasmFunc.name = specName;
    
    // Register it
    this.pass.wasm.specializedFunctions[specKey] = wasmFunc;
    this.pass.wasm.addFunction(wasmFunc);
    // markFunctionReached queues a node referrer for the body with
    // this specialization's type arguments; without these entries the
    // referrer finds no node and the per-specialization traversal is
    // silently skipped, so classes the body constructs never
    // instantiate under the substituted type arguments.
    this.pass.nodeIdToNode[(funcExpr as Node).id as i32] = funcExpr;
    this.pass.nodeIdToModel[(funcExpr as Node).id as i32] = model;
    this.pass.markFunctionReached(wasmFunc);
    // A module-level function's checker-recorded dependencies live on
    // its SYMBOL, which the node referrer above never consults. Without
    // this substituted traversal, generic functions this body calls
    // only specialize during emission, after type layout is frozen.
    if (let (true, deps) = model.symbolDependencies.get(symId)) {
      this.pass.traverseDependencies(deps, model, null, typeArgs, funcExpr);
    }

    return wasmFunc;
  }

  instantiateGenericMethod(ct: ClassType, cd: Node | null, methName: String, methodNode: Node, typeArgs: Array<Type>, model: SemanticModel): WasmFunction {
    let specKey = getSpecializedName(methName, typeArgs);
    let registeredKey = getClassMethodKey(getClassKey(ct), specKey);
    let isStatic = methodNode is MethodDefinition && methodNode.isStatic;
    let methodMap = this.pass.wasm.methodMap(isStatic);
    if (methodMap.has(registeredKey)) {
      return methodMap[registeredKey];
    }
    return this.registerClassMethod(ct, cd, specKey, methodNode, false, false, null, model, typeArgs);
  }
}

function getNodeMemberName(model: SemanticModel, node: Node): String {
  return memberKeyOf(model, node as Node);
}

function isConstructorMethodName(name: String): boolean {
  return name == "<constructor>" || (name.length > 14 && name.startsWith("<constructor>."));
}

function getMethodName(model: SemanticModel, md: MethodDefinition) {
  return memberKeyOf(model, md.name as Node);
}

/**
 * Whether a constructor has body statements to run post-allocation.
 * Synthesized constructors (node-less) never do; a written `new(...);`
 * or an empty block has nothing to run either, unless the constructor
 * has postconditions, which run after the body in that phase.
 */
function ctorHasRunnableBody(factory: WasmFunction): boolean {
  if (!(factory.node is MethodDefinition)) {
    return false;
  }
  let md = factory.node as MethodDefinition;
  if (hasEnsuresClause(md.contracts)) {
    return true;
  }
  let b = md.body;
  if (b == null) {
    return false;
  }
  if (b is BlockStatement) {
    return b.body.length > 0;
  }
  return true;
}
VersionPublishedDependenciesApproved by
0.0.2-preview.1 2026-11-19